The Development Workflow¶
This is the spine of Part II: the whole cycle of building software with Claude Code, and which primitive does the work at each point.
The frame comes from Andrew Ng's AI Engineering Skills Map (2026-08-14) — four pillars synthesised, in his description, by a method "akin to clustering on a massive dataset of jobs and expert interviews": over 10,000 job postings, dozens of structured interviews, plus survey data. One of the four pillars is Using Coding Agents, expanded in its own letter (2026-09-04). That letter's three phases and five skills organise this page; the mapping to Claude Code primitives is this KB's.
Read the headline claim before anything else:
"most effective coding agent use is a complex, highly iterative process"
— Ng, 2026-09-04, explicitly not autonomous long-horizon execution
If you have not yet decided whether your task belongs here or in Part I, start at Choosing Your Mode.
The three phases¶
| Phase | What happens | Primary Claude Code surface |
|---|---|---|
| Planning | Brainstorm, research the codebase, write a spec capturing requirements and technical design, generate an execution plan, review assumptions for security gaps | Plan mode, Explore subagent, CLAUDE.md |
| Execution | Build, test and verify, with autonomy and oversight balanced | Permissions, subagents, workflows, hooks |
| Deployment & monitoring | Deploy, possibly gated by CI/CD; agents watch logs, surface issues, propose fixes | Headless, Routines, Claude Tag — this is where Part I takes over |
The third phase is the handoff point between the two halves of this knowledge base. Monitoring is recurring, well-specified and verifiable — the profile that passes the three tests.
The spec scales with the risk, not with the task¶
"the spec for a greenfield … prototype might be loosely described in a quickly written prompt" … whereas "the spec for a brownfield (pre-existing) project with many users might require much more effort."
This is the most-skipped judgement in phase 1. Writing a full spec for a throwaway prototype is waste; skipping one on a brownfield service with users is how agents produce plausible, wrong, expensive work. Match the ceremony to the blast radius. Part I's spec-first signals (Factory Model) carry the same maturity condition — read them as the mature-project case, not a universal rule.
The five skills¶
1. Directing the workflow¶
Navigating the tradeoffs between speed, cost, technical risk and human effort — deciding at each step how much is yours to do and how much is the agent's.
| In Claude Code | Where |
|---|---|
| Choosing interactive vs. delegated vs. unattended | Choosing Your Mode |
| Model and effort selection, cost per unit of work | Cost & Turn Control |
| Whether this needs one session or several | Session Architecture |
2. Enabling agent autonomy¶
Ng puts the core question directly:
"Do you watch it and go back-and-forth interactively or delegate a larger chunk of work to it?"
and answers it with a caveat worth memorising:
"being able to intervene with high-skill judgement gives much better results"
Autonomy is a dial, not a switch. In Claude Code the dial has real detents:
| Detent | Mechanism |
|---|---|
| Watch every action | plan mode; default permission mode |
| Approve edits, watch commands | acceptEdits |
| Classifier reviews each action | auto — now the default on Pro, Max and Team plans; see Permissions |
| Delegate a bounded side task | subagents |
| Delegate a large fan-out | dynamic workflows, agent teams |
| Nobody watching | headless + a hard --max-turns / --max-budget-usd |
On parallelism, Ng names the decision and the two costs around it:
"you will decide when to set up many agents to run in parallel on a decomposition of the task", "having a human or a higher-level agent orchestrate these other agents", and "how to manage human attention across concurrent agent sessions."
That last clause is the one people discover late. Parallel agents do not just spend tokens; they spend your attention, which is the scarcer resource. Session Architecture covers when parallelism actually pays.
Anthropic's own account of its staff puts numbers on the same constraint: interactive agent hours outnumbered employees 6:1 by August, human attention becomes the bottleneck for agent output (even among non-technical employees, reading all the output of their Claude agents would take half their work week), and staff time shifts toward "meta-work" — building visibility tools and monitoring agent pipelines. (Anthropic, "How employment is changing at Anthropic", Oct 2026; the company's own report on itself.) That is the same pressure Failure Patterns lists as the orchestration tax — and the reason to build the visibility layer (summaries, verdict-only reports) before adding the next parallel agent.
A single-job loop at the "nobody watching" end, and what its numbers trace to. Samuel Stroschein, lix's maintainer, reports (X article, 13 Oct 2026)
agents looped on one job, making the lix version-control engine faster, for "the equivalent of $1M in tokens in 30 days": profile, remove the
bottleneck, benchmark as the reward. His example goal requires each change to give ">10% improvement without regressing other metrics" and runs "until 10 consecutive runs do not yield
an acceptable improvement anymore", a plateau stop. Rust compiles made CPU the bottleneck, so each agent got its own rented dedicated server, driven over SSH from the Codex desktop app:
parallel agents compete for machines as well as for your attention. The dollar figure is the author's and cannot be checked. I checked the eight PRs he cites against the repo
(gh api, 2026-10-19; all are his own). All are merged, between 2026-07-29 and 2026-09-14 (47 days, not 30), and six of the eight headline figures appear in the PR bodies at about the stated size (for example #938, 1.49 s to
0.414 ms; #969, 309.38 s to 10.17 s), with small differences (for #1184 the PR gives a median of 215.9 ms to 2.90 ms where the article says about 222 to 2.5). Two are narrower than they read.
For #1224, the 105x is the PR's own Ryzen discovery screen (Rocks, 1K history, merge wall 393.439 to 3.747 ms), while its final qualification table shows -81.47% and -73.67% wall time on the two backends at that history.
And the 867 ms to 0.26 ms of #1782 is a native probe quoted in a commit message, while the PR's QA report gives 87.8 ms for a two-row update at 1M rows and the PR description calls its figures
"single-run observations, not latency guarantees". Commits on main in the 30-day windows ending 2026-07-28, 08-27 and 09-26 were 591, 2,325 and 662 (API count), so his "6x" depends on the baseline chosen.
Context management belongs to this skill too — see Context Management and Memory Patterns.
3. Reviewing the work¶
Matched behavioural and functional testing, LLM-as-a-judge evals, and security audits.
"Some workflows will have all testing and validation fully automated so the agent can check its work and know when it has succeeded"
That sentence is the whole of Verification compressed: the agent knowing when it has succeeded is the stopping condition. Where full automation is not possible, Ng points at eval sets, "perhaps with LLM-as-a-judge".
Practical placement in Claude Code:
-
/code-reviewand/security-reviewon a diff. v2.1.215: "Claude no longer runs the/verifyand/code-reviewskills on its own; invoke them with/verifyor/code-reviewwhen you want them." v2.1.218 then "Changed/code-reviewto run as a background subagent, so review work no longer fills your conversation."That v2.1.215 sentence no longer holds unqualified. v2.1.246: "Changed
/code-reviewso Claude can also start it on its own on Bedrock, Vertex AI, and Foundry, through the Claude apps gateway, and when telemetry or non-essential traffic is disabled." The word also implies autostart had already returned on other platforms — but no changelog bullet records where it was reinstated (the full 6,362-line file carries only these two entries on the subject, checked 20260906). So: do not design a loop on the assumption that/code-reviewruns only when invoked. If you need it to stay manual, pin it withskillOverrides: {"code-review": "user-invocable-only"}(skillOverridesshipped v2.1.129) rather than relying on a default that has already flipped once. - An adversarial review subagent in a fresh context, rather than a second session — the official best-practices page notes the subagent form works "without you copying findings between windows." - Hooks for the checks that must never be skipped. Advisory text gets ignored; aStophook does not.
The trap: a reviewer prompted to find gaps will find some, whether or not any exist. Calibrate the instrument before trusting it — see the calibration rule.
One practitioner ran this as an experiment: a 96-line file reviewed ten times by fresh Claude Code sessions with every change applied. "Review and improve" grew the file 42% and invented a feature by round 3 that round 4 then treated as spec; "is anything actually wrong? 'no changes needed' is a valid answer" and a short design-principles file each stopped at three consecutive no-change rounds. One file, one model, one run per variant — a demonstration, not a study (kachar.dev, "Drift by a thousand suggestions", Oct 2026). The same author's companion essay argues for phrasing prompts as questions that leave the how to the model, with the done-condition still written by you up front (kachar.dev, "Orders get obedience. Questions get opinions.", Oct 2026; the 10,752-prompt breakdown is the author's own prompts, so it describes one person's habits). Failure-mode entry: Review-loop drift.
4. Customizing the agent and its environment¶
Skills, plugins, MCP servers, and standing context — Ng names the file explicitly, AGENTS.md / CLAUDE.md, holding codebase information, architectural assumptions, code style and data-access patterns — plus preserving state across sessions and coordinating across a team's agents.
| Concern | Doc |
|---|---|
| Standing context, and pruning it | CLAUDE.md |
| On-demand procedure | Skills |
| Deterministic rules | Hooks |
| State across sessions | Memory Patterns |
| External tools | MCP Security |
The rule that governs this whole skill: an instruction that must hold with zero exceptions does not
belong in prose. Official guidance is blunt about it — "Unlike CLAUDE.md instructions which are
advisory, hooks are deterministic and guarantee the action happens." And on bloat: "Bloated
CLAUDE.md files cause Claude to ignore your actual instructions!" Run /doctor for proposed cuts.
A practitioner example of the same rule in the field: Geoffrey Huntley frames the human's remaining job in a loop-engineering workflow as owning vision and verification, with verification acting as back pressure that keeps the loop honest — and says a recurring agent mistake is fixed with a deterministic pre-commit hook that fails the commit and injects a corrective prompt, not by editing AGENTS.md or adding skills. Simon Willison's excerpt gives the instance: a hook checks the git diff for bypassed diagnostics modules, fails the commit and injects a prompt, taking agent compliance to "ten out of ten" where AGENTS.md instructions drift. Both are one practitioner's report, not a measurement, but the hook doubles as a stopping condition — the agent cannot declare done past it. See Hooks and Verification.
5. Coding agent foundations¶
How the agent retrieves, how the context window is managed, and the failure modes that follow. Ng names four:
"overengineering a simple solution, losing rigor because the agent lacks an explicit verification process, stopping short of the goal"
and separately:
"agent actions that risk destruction of files or production data"
The first three are addressed in Common Failure Patterns; the fourth in Permissions and Agent Security Hardening.
Overengineering is the one to watch for, because it does not look like failure. It looks like thorough work. It is the reason a spec that says what not to build is worth writing.
What the other pillars contribute¶
The coding-agent skill does not stand alone in Ng's map.
Software engineering fundamentals (2026-08-28) — the argument is that agentic tools remove the friction that used to force developers to confront tradeoffs, so without fundamentals you make "poor tradeoffs in latency, availability, consistency, reliability, maintainability, simplicity, and/or cost" without noticing the tradeoffs existed.
"developers who deeply understand how software works vastly outperform those who vibe code without understanding"
This is the corrective to the idea that the model makes expertise optional. It makes expertise higher-leverage, because expertise is now expressed as steering rather than typing.
Building and deploying AI applications (2026-08-21) — if what you are building is itself AI-powered, its outputs are unpredictable, which demands "iterative development processes where engineers continuously build, examine results, and decide next steps based on intermediate findings." Ng singles out one skill above the rest:
"a disciplined evals/error analysis loop"
Note the shape of that: it is a loop, and its stopping condition is an eval. That is Part I's subject arriving from the other direction.
A worked reference implementation¶
First-party disclosure
ClaudeWarp is written by the same maintainer as
this knowledge base. Every figure attributed to it here is self-reported and has not been
independently reproduced. It is cited in five docs (docs/11, docs/22, docs/24, docs/29,
docs/35) and that relationship applies to all of them.
Two consequences worth stating plainly, because this KB applies the same scepticism to BrainGrid and Hindsight/Vectorize as vendor sources and owes itself no less:
- Treat it as a worked example, not as evidence. Where it reports a measurement — the per-session cost floor in Cost Control — the caveat there is the operative one.
- The dependency runs both ways. ClaudeWarp ships
/claude-warp-sync-research, a skill whose documented job is to fetch this repository via the GitHub compare API and implement what it finds. So a pattern this KB reads back out of ClaudeWarp may be a pattern ClaudeWarp read from this KB — citing it as an external corroboration would be circular. Where the two agree on a construct, assume shared origin unless the provenance is traced.
ClaudeWarp is a public loop harness built on top of Claude Code — "scaffold, guard, and schedule autonomous loops in any project" — and it is a useful thing to read even if you never install it, because it makes the phase-3 handoff concrete.
Its own framing of the gap it fills:
"Autonomous agents fail in two ways: they stop when you leave, and they say 'done' when it isn't."
Three of its design rules transfer without adopting the tool:
- State that outlives the session. Goals, loops and task queues live in git, so a crash, a reboot, or a different machine can resume. Contrast the native primitives, which are session-scoped by design.
- A budget is part of the definition, not an afterthought. Every scaffold carries a hard
$and turn cap. See Cost & Turn Control. - "Not run" is not "green." An unrun check is reported as
not run, and an uncertain result asdone_with_concernsrather than rounded up to done. This is the same defect Session Architecture documents as a fan-out reporting clean after most of its agents died.
The property most worth copying is architectural:
"the harness is built to disappear:
/claude-warp-syncreads every Claude Code release and retires each component the moment it ships natively."
A harness should be designed to shrink. Every component you build on top of a platform that is
still moving is a liability with a maturity date. Building the retirement mechanism at the same time
as the component is what keeps the boundary honest — and it is the discipline this knowledge base
needs too, which is why eight stale facts had to be corrected in v3.0.0.
Read that quotation as a design statement, not a result. It is the project's own description of
what the mechanism is for, quoted as written. Measured against its own changelog, /claude-warp-sync
has run twice — reading 65 Claude Code releases in total — and retired zero components; both runs
record "no Harness row is superseded." The mechanism works, the platform simply has not yet
absorbed anything it covers. The full measurement, and the three lessons that follow from it, are in
Harness Patterns § What the shrink mechanism actually
measured.
Related¶
- Choosing Your Mode — the decision that precedes this page
- Session Architecture — one session or many
- Explore → Plan → Implement → Commit — phase 1 and 2 in practice
- Verification — skill 3, in depth
- The Loop Contract — where phase 3 hands off to Part I