Architecture Was Designed for Humans. It's Time to Revisit It.
Agent-built, human-accountable: the operating model for software after coding.
Every architecture principle we follow was written for one kind of builder: a team of humans.
How we split systems, how we estimate, how we reuse, how we review: all of it assumed people writing code by hand and people maintaining it for years. Those assumptions served us well for decades. They are now worth a fresh look.
Software is moving towards a hybrid model. Agents do more and more of the building. Humans stay accountable for every outcome. One way to name it is agent-built, human-accountable delivery. It deserves its own architecture thinking, rather than the old principles with an AI tool added on.
Our principles carry a hidden assumption
Look closely at the rules we treat as timeless and you’ll find a human at the centre of each one.
We split systems into services partly so separate teams could work without stepping on each other. As Melvin Conway observed back in 1968, systems tend to mirror the communication structure of the organisations that build them.1
We obsessed over reuse and “don’t repeat yourself” because writing code was expensive and keeping duplicates in sync was error-prone for people.
We costed projects in people and months, because people writing code was the biggest cost.
We designed frameworks and abstractions to fit what a human brain can hold at once.
None of these were wrong. They were right for a world where humans did all the building. That world is changing.
What changes when agents build
| Concern | Human-built era | Agent-built, human-accountable era |
|---|---|---|
| Biggest cost | Writing code (people × months) | Verifying, reviewing and running it |
| System boundaries | Follow team boundaries | Follow accountability and blast radius |
| Reuse vs rewrite | Reuse at almost any price | Regenerate when it’s cheaper than coupling |
| Documentation | Afterthought, often stale | Executable intent: the spec agents build from |
| Source of truth | The code | The contracts, tests and decisions around the code |
| Change pace | Big rewrites every 5–10 years | Components replaced in weeks |
| Who touches production | Named engineers | Agents with tight permissions, owned by named humans |
Seven principles for agent-built, human-accountable software
- Every component has a human owner. An agent can build it. A named person answers for it.
- Design for comprehension. Small modules, explicit contracts, plain names. If a person can’t understand it in one sitting, it’s probably too big, whoever wrote it.
- Contracts and tests are the real product. Code can be regenerated. The interfaces, rules and tests that define “correct” are what you protect.
- Build for replacement. Assume any component may be rebuilt next quarter. Stable contracts outside, freedom inside.
- Write intent down. Decisions, constraints and the reasons behind them become the context agents work from. Undocumented intent becomes wrong code.
- Least privilege for agents. Agents get exactly the access a task needs, every action is logged, and the riskiest steps wait for a human.
- Cost the whole loop. Budget for review hours, compute and governance, not just build effort, because that’s where the money now goes.
What this means for architects
The architect’s job doesn’t shrink. It moves up.
Less time goes into drawing boxes for teams to fill in. More goes into setting the intent, the boundaries and the guardrails that agents build inside, and making sure a person can always explain, defend and own what was built.
An example. Picture a team that needs a new service to calculate customer fees. In the old model, an engineer spends two weeks writing it, then it lives for years. In the new model, the architect spends a day writing down the contract: inputs, outputs, rounding rules, edge cases and the tests that define “correct”. An agent builds the service in an afternoon. When the fee rules change next year, the contract and tests are updated, and the inside can simply be rebuilt. The code is replaceable. The contract and its owner are not.
This approach, tried in a personal lab, tends to be slower in the first week and much faster every week after: clear module boundaries, design decisions written down before an agent touches code, and nothing merged that a person hasn’t understood.
Organisations that adapt their architecture thinking for this model are likely to build faster and more safely. Adding AI to principles written only for human teams can produce more code without more understanding.
Agents will do the building. Humans will still carry the accountability. Our architecture needs to be designed for both.