The bottleneck moved
5 min read
By the end you can tell whether a task deserves the full loop, and you know the three habits that make it pay.
TL;DR
- Agents make plausible code cheaper to produce. Domain clarity, useful decomposition and evidence before "done" help turn that output into useful changes.
- Match the workflow to uncertainty and risk: direct work for clear changes, a short plan for dependencies, explicit outcomes and review for consequential work.
- Setup and review have a cost; measure whether the work improves. Start with a useful constraint, not a perfect setup.
The constraint moved
Cheaper code generation makes the surrounding engineering decisions more visible.
Agents make producing plausible code much cheaper. That exposes the constraints around it: deciding what should change, supplying missing context, integrating the result and establishing that it works. Different teams have different bottlenecks; typing speed was never a complete account of software delivery.
Teams that treat the agent as a code generator let it type, handle everything else as before, and spend more time fixing output than the typing saved. Teams that ship well formulate the work so the agent can execute it correctly. Vague specifications produce guessing, and guessing produces output that looks right and is not.
The people building the models agree. In July 2026 an Anthropic engineer opened a field guide to Claude Fable 5 by calling it "the first model where I find the quality of the work is bottlenecked by my ability to clarify its unknowns."
Three habits
All three are formulation, not generation.
- Domain clarity before code. The agent does not know your business, your conventions or why the codebase looks the way it does. Load that context first: AGENTS.md, skills, the research phase.
- Decomposition where it helps. Split a large change into coherent steps with clear dependencies. A quick, well-understood edit can stay one task.
- Evidence before "done". The agent can say the change is complete and be wrong. Choose checks that exercise the intended result: a regression test, build, lint, rendered page or a direct content check. The check should fit the change.
The first two habits define the expected outcome; the third measures against it.
The four unknowns
Every gap in a prompt is one of four kinds of unknown, and each has a different fix.
The same guide splits the human half of formulation into four questions. The mapping onto this manual is mine, not his.
| Quadrant | What it is | Where this manual handles it |
|---|---|---|
| Known knowns | What your prompt actually states | The prompt itself |
| Known unknowns | Questions you know you have not settled | Open questions in the research note, settled before the plan (Chapter 4) |
| Unknown knowns | Context so obvious you would never write it down, though you would spot a violation instantly | The team instruction file, AGENTS.md (Chapter 6) |
| Unknown unknowns | What neither of you thought to ask | The blind spot pass and implementation notes (Chapter 4), the quiz (Chapter 5) |
The loop test
Use the least process that makes the outcome clear and the risk reviewable.
Start with the native agent and your normal repository checks. Size the work before adding a workflow:
- Clear and contained: ask for the change directly, with a focused check. A typo or familiar rename rarely needs a separate plan.
- Unclear or dependent: inspect the relevant code, settle material questions and write a short plan. Keep coupled steps together; record decisions the next step needs.
- Risky or unfamiliar: define the expected behavior, failure cases, permissions and human decisions explicitly. Add deeper investigation and independent review where a mistake would matter.
File count is a clue, not a threshold. A one-line authorization change can deserve more scrutiny than a mechanical rename across fifty files. Reversibility helps recovery; it does not make a behavioral bug harmless. The six functions in Chapter 4 give you a checklist of what must be covered, not paperwork to generate for every task.
Two teams, one quarter
One team's investment paid back over a quarter; your timeline needs measurement.
The clearest case I have seen: two teams at the same company, in adjacent areas of the same product, using the same agent.
Team A turned the agent loose immediately and celebrated the early velocity. By month three they were shipping at roughly the pre-agent baseline, with higher defect rates and visibly drained senior reviewers.
Team B spent month one on the practice: AGENTS.md drafted and iterated, skills written for the team's patterns, hooks configured. They shipped no agent-led work that month. By month two they were back at baseline velocity. By month three they shipped at noticeably better quality and velocity than before the agent.
The observation motivates measuring setup, delivery, review and defects together. It does not establish that every team should lose its first month or that this workflow caused the difference.
| Case note | What this account establishes |
|---|---|
| Provenance | Author-reported, anonymized engagement |
| Evidence | The qualitative account above; no underlying task counts or time series are published here |
| Comparison | Adjacent teams before and after adoption, without controlled task selection |
| Limitations | Team differences and the combined interventions prevent causal attribution to one agent or method |
| Transfer | Measure your own baseline and costs; expand when the observed outcomes justify it |
Start small
The practice does not need to be perfect to pay.
A few useful lines in AGENTS.md can prevent a repeated mistake. A short note can settle an unfamiliar task. Teams that build the perfect workflow before running it get stuck, because there is always one more rule, skill or hook to add.
Write the few useful constraints the first task needs, run bounded work through the agent, and add rules justified by observed failures or a specific risk.
When it breaks
- One workflow for every task. Ceremony can slow a clear edit; missing investigation can sink an unfamiliar one. Run the loop test first.
- Waiting for a promised quarter-end payoff. Track outcomes from the start; change or stop a pilot whose costs and failures are not justified.
Do this Monday
- [ ] Size the next task with the loop test: direct work, a short plan, or deeper investigation and review.
- [ ] Write one sentence saying what "done" means and which check will show it. Add only the context the agent is missing.
- [ ] Run it with the native agent first. Add a rule, skill or plugin for a documented need, missing capability or repeated failure, then check whether it helped.
Go deeper
- Templates: Appendix B.2, the AGENTS.md skeleton; B.3, the six-phase loop checklist.
- Deep dive: Appendix D, Chapter 3 - the Fable 5 unknowns frame, the METR trial and its caveat, and the February to April 2026 regression.
- Sources: Appendix C.