Contents
Why
The model, where humans fit in it, and the risks it balances.
-
From Dark Factory to Software Garden
Why we stopped calling it a dark factory. The metaphor that set the ambition, why it leaves people in the dark, and the garden that fits better: agents grow the code, humans tend the structure as growth wears it down.
-
It was never the typing
For many engineers, writing code is identity. Agents bring a real loss, a team that splits, and a temptation to lead by fear. Name the loss, protect the dip, pair across the spread, and show what carries over.
-
The role of humans
Humans move to the edges: vision and validation, with agents implementing in the middle. And the answer to “how will I know the code is any good?”
-
The organisation of agents
Zoom from a colony of agents, through the processes they follow, into a codebase garden. Watch it run wild, then partly structured, then refactored into a structure that holds up at agentic speed.
-
Engineering Risk
Too careful loses the market; too careless loses trust. Engineering manages two trade-offs: speed against risk, and speed against complexity.
Quality
How you know it's any good, at agentic speed.
-
Agentic Loop Engineering
TDD is the template: a hard correctness condition lets an agent climb to correctness. Then loops inside loops, escaped defects, trade-offs, an import graph that decides how much of the suite runs, and why it's engineering all the way down.
-
There are no flaky tests
An intermittent failure is a real defect, in the test or in the product. Why noisy signals break agent loops, how to control time, and why every fix should cover the whole class of defect.
-
All software fails somewhere
All software fails somewhere. Keep the signal non-negotiable, reason at compiler speed instead of human speed, stack integration and scenario tests to find the failure conditions, and feed them back so the defect rate falls as throughput rises.
-
Point them at a number
Telemetry is a test. Agents in a change, build, deploy, load and measure loop hunt their own bottlenecks and disprove their own theories. Check the instruments, then give agents an objective and guardrails and let them find the work.
-
Zero-eyes PR approval
Agents review and fix each other's pull requests until the review is clean. Humans stop reading every PR and start engineering the loop: what escapes it, and how to make it stronger.
Structure
Know where the model is reliable, and harden the edges at compiler speed.
-
Every model has an envelope
Models aren't good or bad, or interchangeable. Map where yours is reliable, and harden the edges with structure.
-
Rules that enforce themselves
A rule in a document is advice; a rule in the build is a fact. The enforcement ladder, ratchets, narrow exceptions, an always-green baseline, and turning review comments and incidents into checks.
-
Derivation over duplication
Write each fact once and generate the rest: seven SDKs from one spec, docs and help from compiled sources, a generator you fix instead of its output, and CI that proves nothing drifted.
System
The tools agents use, and the gates they pass through.
-
Designing for agent users
Agents use our tools too. Data rather than prose, one job per output channel, respecting the context budget, dry runs, self-describing help, and SDKs whose types and errors tell the truth. And one level down: a codebase designed for the agents that change it.
-
Get to the eleventh
Nobody one-shots good software. Guardrails make correctness cheap; fitness takes rounds. Prove an API before publishing with a network of consumers, user testing at scale by proxy, and grow that network as fast as the code.
-
The merge button is part of the system
Auto-merge is only as safe as what the branch refuses. Required checks that can actually fail, stable branches, settings drift across a fleet, a vulnerability-to-release loop with no human in it, and handing admin changes to humans.
Organisation
Rolling it out: people, teams, tools and bottlenecks.
-
The bottleneck moved
The Theory of Constraints for agentic engineering: find where work waits, fix it, find the next one.
-
The constraint is mindset, not the model
Same model, opposite results. The beliefs, incentives and learning curve that decide which.
-
You are the skill
Tools churn. Your judgement, encoded as skills, rules and checks, is what scales.
-
Conway's Law still holds
Features cross teams. Every repository declares what it owns, and a planning skill places each capability with its owner.
-
Start with one garden
Choose one codebase, prepare it, prove it, and let it seed the next.
Case studies
What happened when we did it: the numbers, from the git history.
-
The Cambrian explosion
One engineer went agentic. One SDK became 22 repositories and seven languages, and one owner became a pod of three.
-
Three shapes
Three engineers, independently. A fence, a gate and a loop: where the speed went, and who decides a change is done.
-
c8ctl
Where the method left the SDKs: a one-shot CLI, hardened so incomplete commands are impossible, now grown by 26 people.
Conclusion
What it comes down to.