Learning outcomes

What a graduate can do

Course-level outcomes describe overall capabilities. Module-level outcomes map each module to specific, assessable capabilities. Assessment grades against these outcomes.

Course-level outcomes

11 outcomes
LO1

Articulate Agentic Software Engineering as the discipline of structured, auditable human-agent workflows, and explain how the discipline differs from tool skill, casual prompting, and general LLM use.

LO2

Apply the conceptual frame the discipline rests on: the human-agent division of labour, the auditability principle, the seven-part anatomy of an agentic workflow, the co-evolution of intent and build, and the evolutionary spiral.

LO3

Frame an agentic project by producing the framing artefacts (problem statement, stakeholder list, testable definition of done, out-of-scope list) and by conducting a reverse-interview with the agent to surface missing information.

LO4

Write a complete specification that approximates Knuth’s five criteria (finiteness, definiteness, input, output, effectiveness) and that gives the agent enough information to make autonomous decisions correctly.

LO5

Engineer the context an agent receives by designing and maintaining context files (CLAUDE.md, AGENTS.md), curating context as a budgeted resource, and converting course-corrections into durable project knowledge.

LO6

Apply safety infrastructure to agentic work, including Git practices, sandboxing, and trajectory management, and recover from agent error without catastrophic loss.

LO7

Design and operate verification gates appropriate to the project, detect verification theatre, and evaluate agent output against the MRP standard.

LO8

Decompose tasks for multi-agent workflows using the five workflow patterns, justify the cost of explicit orchestration relative to implicit, and design coordination between agents that work in clean scopes.

LO9

Identify security and governance risks specific to agentic systems (prompt injection, blast radius, supply-chain attacks on tool servers), and apply the engineering and organisational responses to them.

LO10

Operate a project through multiple turns of the evolutionary spiral, make commit-point decisions, and recognise drift as it develops.

LO11

Read the labour market and the entrepreneurial environment with reference to AI’s effect on tasks rather than jobs, and position themselves in the bifurcation between expert-frame work and pure-implementation work.

Module-level outcomes

19 modules

The student can articulate why ASE is a discipline shift rather than a tooling shift, situate the current transition within the historical arc from ENIAC patch cables to vibe coding, name the empirical evidence for the speed-versus-trust gap (68% PR delay rate, solve-rate collapse under audit), and apply the autonomy-level framework to any agentic tool.

02. The human role

The discipline

The student can sort developer work into the three categories (eroding, stable, compounding) with concrete examples, recognise the four structural risks of the discipline (skill erosion, black-box codebases, responsibility gaps, training-data bias), articulate Polanyi’s residue as the conceptual ground for the compounding category, and name the four barriers to industrial adoption identified in the 2026 systematic review.

The student can use the practitioner mental model of agents (context window as the agent’s whole world, tools as action space, planning as next-step generation under context) to predict where a given prompt will succeed or fail, and can diagnose agent failures against the four-mode taxonomy (hallucination, misalignment, ambiguity collapse, sycophancy).

The student can decompose any agentic workflow into its seven parts (intent, specification, context, plan, execution, verification, audit trail), explain the auditability principle and its operational consequences, and recognise an audit trail produced as a byproduct of agentic work.

05. The ADE typology

The discipline

The student can read any ADE as an instance of the six-pillar architecture, classify it into one of the three ADE categories (terminal/CLI, IDE-integrated, browser-based), evaluate a permission configuration in terms of blast radius, and apply the minimal-footprint principle to a concrete sandboxing decision.

The student can produce a framing document for an agentic project (problem statement, stakeholder list, testable definition of done, out-of-scope list with defensible boundaries), apply Brooks’s four-way taxonomy to a constraint set, and run a reverse-interview with the agent across the six question clusters (purpose, user, success, boundaries, constraints, testability).

The student can describe a modern web application architecture at the level needed to direct an agent intelligently, trace a request through the full cycle from button click to database query and response, and recognise when an agent’s proposed architecture is sound, broken, or merely fashionable.

The student can specify a user interface at directing-quality precision (user flow, information hierarchy, interaction model, feedback design), distinguish descriptive from explanatory documentation, and recognise illegibility in an interface, codebase, or document as a control problem rather than an aesthetic one.

The student can distinguish using AI to build software from building software that contains AI, address the architectural questions cognification raises (inference location, latency budget, model choice, failure handling), and apply agent-economics reasoning (token pricing, prompt caching, frontier-versus-local trade-off) to a product design decision.

The student can write a complete specification containing goal and business rationale, verifiable success criteria, architectural guidance, validation approach, and known pitfalls; can diagnose categories of agent failure against categories of specification gap; can run the reverse-interview methodology to extract specification material from underspecified intent; and can articulate the rationalism-empiricism axis and ASE’s empiricist position, recognise the co-evolution of intent and build, execute the mechanics of one turn of the spiral (intent revision, context update, safety positioning, build, verification, review), make commit-point decisions, and detect drift as it develops.

The student can design a project-specific CLAUDE.md or AGENTS.md file with appropriate content across the four kinds (standards and processes, code quality expectations, problem-solving heuristics, collaboration protocols), maintain a lessons-learned file across tasks, and recognise context degradation in its three forms (overflowed budget, ad-hoc artefact, neglected maintenance).

The student can apply Git practices appropriate to agentic work (pre-invocation commits, atomic commits with rationale, branch discipline for safe agent output evaluation), configure permission boundaries that scope blast radius, and execute trajectory-management interventions in response to the standard drift signals during a session.

The student can design verification gates appropriate to the failure modes a project actually faces, recognise verification theatre when they see it, resist gate bypass under deadline pressure, and produce evidence sufficient for the MRP standard.

The student can distinguish implicit from explicit orchestration, decide when the cost of explicit orchestration is justified (given the 15x token premium), break a task into sub-tasks with clean boundaries and isolated context, and apply each of the five workflow patterns (prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer) to a concrete decomposition.

The student can produce a coordination design for a multi-agent workflow that specifies patterns, roles, boundaries, and cost-benefit justification, can teach an orchestrator to delegate effectively, can scale effort to complexity, and can design tools for the agents to use.

16. Review and quality

The engineering

The student can review foreign code (agent-generated or legacy-inherited) against the MRP’s five criteria, distinguish surface correctness from rigorous-audit correctness, apply the dependency-graph methodology to a legacy migration, and rewrite tests from logical intent rather than literal translation.

The student can identify prompt-injection vectors in an agentic system, design permission boundaries that contain blast radius, evaluate an agent’s tool-server dependencies for malicious servers and supply-chain risk, apply the OWASP Top 10 for Agentic Applications as a practical reference, and distinguish security questions (what could happen) from governance questions (what is sanctioned, recorded, and reportable).

The student can analyse a startup case study for value-creation mechanism, organisational enabling condition, and managed-or-ignored risk; can apply the two-mechanism frame (cost compression and cognification) to a new opportunity; and can name the new bottlenecks that replace development cost and timeline as primary obstacles.

The student can articulate the AI-affects-tasks-not-jobs thesis with empirical support, identify the human-sandwich pattern in real workflows, read employer signals that distinguish genuine ASE practice from performative mention, and evaluate a role for whether it will develop or erode the compounding skills.

Mikael Alemu Gorsky

Mikael Alemu is an educator and researcher, and the author of two programs: Agentic Software Engineering, on building software with AI agents, and Building AI-Native Agentic Systems, on building software that thinks.

He teaches at the Holon Institute of Technology, near Tel Aviv, where Agentic Software Engineering runs as a credit-bearing course. He is an educator and researcher.

Nine published works, 76 citations. A 350-page textbook under contract with a major academic publisher.

Teaching and programs

Agentic Software Engineering — program, preprint and textbook

The discipline of structured, auditable human-agent workflows for building software. The human frames, specifies and judges. The agent executes. Nineteen modules in four parts, built on a running project called Tribunal, a web application in which agents argue opposing sides of a case and a judge agent decides. Taught for credit at the Holon Institute of Technology.

Agentic Software Engineering curriculum

Building AI-Native Agentic Systems — program, paper and book in writing

How to build systems that hold a language model as a working component, and treat that component as what it is: stochastic, slow and metered. Fourteen modules in four parts, about seventy hours. The running project is the Observatory, a news agency that watches sources, selects what matters and publishes on a cadence.

Research and analytics

Publications — journals and proceedings

Nine works, 76 citations. Research on artificial intelligence in education, with Ilya Levin and Alexei Semenov.

The AI Pravda — LinkedIn newsletter

Critical analysis of artificial intelligence and its effect on work and society. 5,500+ subscribers. The complete archive of 103 issues (2023–2026) is published in full at mgorsky.net/theaipravda.

Subscribe to The AI Pravda on LinkedIn

Pro bono

AI for seniors — free workshop

Helping older adults use everyday AI tools. Delivered to Russian-speaking communities in Israel.

For older adults, artificial intelligence is about preserving quality of life, maintaining autonomy, and sustaining the feeling of independence that defines dignified aging. For seniors who have emigrated, AI becomes a bridge: it can translate documents, explain official letters, help compose emails in the local language, and guide users through government websites. The workshop has been delivered to Russian-speaking communities in Israel, where participants — many of them in their 70s and 80s — discovered that AI could help them read Hebrew documents and communicate with Israeli institutions.

Startup competitions — unpaid time

Judging and mentoring early-stage ventures. Helping teams clarify their value proposition, assess technical feasibility, and prepare for the realities of scaling an AI product.

AC/VC LinkedIn group — community

A group for developers and students working with coding agents. The community shares practical insights, code examples, tool comparisons, and honest assessments of what works in production.

Join the AC/VC LinkedIn group

Recent

Important Links