A1 · module overview
Why an agile agent workflow
The first module builds the philosophy and the frame. It makes the case for a pragmatic, story-led, agent-driven way of building software, names the two roles and the two layers it runs on, and fixes what “done” means — so every later module is the same loop applied to one more rung. The crucial idea is a pairing: a Claude agent is a fast, tireless implementer of well-specified thin slices, and the human is the source of decomposition, judgement, and acceptance.
By the end of A1 you can say why the workflow works and where it does not, read the framework — the roadmap-and-spec layers, the four artifacts, and the Author/Operator loop — and recognise the one running project, the Portal, that every lesson and the exemplar are built on.
Rationale & intentions
Two habits sink most software built with AI. Prompting without a plan yields code no one can trust; writing one enormous specification yields a document no one finishes. Both skip the unit that makes work tractable — a thin slice of value, proven before the next begins. This module makes the case for that unit and names the framework the rest of the course uses to produce it.
The thesis is a pairing, not a replacement. An agent has throughput and patience a person cannot match, but no taste for what matters; a person has judgement and accountability, but limited tolerance for repetition. Run as a tight loop over thin, provable increments — the human deciding and accepting, the agent specifying and building — the two compound into something neither reaches alone. That is what the modules ahead operate, and what A1 sets out so the operation is deliberate.
- Frame
- Why pragmatic, story-led, agent-driven development works — and where it does not.
- Vocabulary
- The two layers, the four artifacts, and the Author/Operator loop the course runs on.
- Standard
- What “done” means here: correct by definition — a closure over traced, executed checks.
- Project
- The Portal, the one system every lesson and the exemplar are built on.
Master this module and the rest is repetition with judgement: the same loop, applied to one rung after another.
What we are building — the agile framework
Before the lessons, three design pieces lay out the framework the whole course runs on — its structure, its vocabulary, and how it moves. Read them as the blueprint; every lesson below puts one piece to work, and every later module applies the same shape to a new rung.
The Author/Operator loop · one rung at a time
A workflow is a shape you can repeat. These three pieces — the layers, the artifacts, and the loop — are that shape; the lessons put each to work.
The two-layer model
Roadmap over specs: how delivery is planned and how each rung is defined and proven — and why the spec is the single source of truth that feedback edits.
The four artifacts
The vocabulary every rung uses — a roadmap.md, a spec, the user stories, and the agent brief (.llms.md) — and the distinct question each one answers.
The Author/Operator loop
How the framework moves: the human sharpens and accepts, the agent specifies and builds, and the increment ships thin but robust — then the loop adapts.
Module navigation
Six lessons carry the module from the case for the workflow to the project it runs on. Read them in order — A1.01 starts — and the framework above turns from a blueprint into something you can operate.
The two failure modes
Why vibe coding and big-bang specs both fail, and the case for thin, provable slices.
Pragmatic Programming, revisited for agents
The pragmatic canon re-read for a world where an agent writes the code: what changes, what does not.
The Author/Operator loop
The two roles and the cycle that runs every rung, end to end.
Two layers: roadmap and specs
Separating how we deliver from what we build and prove; the spec as the single source of truth.
Correct by definition
What “done” means: a closure over traced, executed checks, and the quality gates that hold it.
Meet the project: Portal
The running project, carried from an empty repository to a deployed, multi-surface platform.
Begin with A1.01 — The two failure modes, then read in order to A1.06. The next chapter, A2 — Decomposition, turns this framework into a backlog of user stories. The companion course, Functional Programming in Elixir, builds the Portal’s Elixir and OTP foundations.
References
The sources this module’s case rests on, and where the framework it names is defined in the course.
Sources
- Hunt & Thomas — The Pragmatic Programmer — pragmatic habits and tracer-bullet delivery.
- Beck, K. — Extreme Programming Explained — small batches and short feedback loops.
- Anthropic — Building effective agents — the agent as a fast implementer of well-specified work.
Related in this course
- A0.2 · What we are building — the framework this module argues for.
- A0.2.1 · The two-layer model
- A0.2.3 · The Author/Operator loop
- Companion · Functional Programming in Elixir