CODING IS DEAD.
Long live
software engineering.
Humans own product and technical design. Give agents the implementation and build the software factory.
How should we build software in the age of AI?
We can build far more software if we stop writing it all ourselves.
Move up the abstraction stack.
Use agents to build more useful software than you could implement yourself.
Developers should take responsibility for the product and technical design: what it needs to do, how the parts fit together and where failure would be costly.
We’ve been through this before.
Some assembly programmers resisted higher-level languages because they could write more efficient code by hand. But faster computers made it affordable to trade some efficiency for shorter development time.
Judge agents by the total cost of delivery and maintenance, and by how much useful software they help you ship.
Design with agents, then let them build.
Work out the product and technical design with agents, then give them the full implementation.
- Humans own
- Product goals, architecture, API contracts, data models, authentication boundaries and performance budgets.
- Agents deliver
- Implementation, integration, migrations, documentation and tests, plus architecture and security audits.
The working loop
Define the product.
Agree on who it serves, the problem to solve, the smallest useful journey and how you’ll judge success.
Design the system.
Work out the technical design with agents. Compare approaches, challenge assumptions and record the trade-offs.
Let agents build it.
Have agents deliver a complete, working slice, including integration and tests. Separate agents check it against the requirements.
Review the working product.
Humans try the user journey, check the product and technical design, and review evidence from independent agents.
Refine the design and repeat.
Request product and technical design changes as gaps become clear. Have agents implement and recheck each revision.
You remain responsible for the design and for what reaches users.
Optimise the software factory.
Put your effort into automated testing and review so routine changes can ship without you reading every diff.
The agent that built a feature can miss the same mistake when it writes the tests. Have other agents check behaviour against the requirements, review architecture and audit security.
Use separate review contexts so agents don’t simply inherit the builder’s assumptions.
Most PRs shouldn’t wait for human review.
Keep PRs as a record of the change, decisions and checks. Human approval should be optional for most changes, and developers can request a review whenever they want.
Have a categorisation agent approve low-risk changes for merge when they fit the agreed design, are easy to reverse and pass independent checks.
Route changes to the agreed architecture or technical design, unusually complex work and changes with serious consequences to the right staff member. Point to the areas of risk and explain what needs their judgment. Escalate uncertain classifications too.
Keep work moving through the whole system.
Track time from idea to a usable result, including waits for decisions, environments, reviews and rework. Fix the largest constraint, then measure again. Limit work in progress so unfinished tasks don’t pile up.
Borrow the focus on flow from Toyota’s production system and the attention to constraints from The Goal.
When a defect escapes, add a check that would have caught it.
Move the work to the cloud.
Developers shouldn’t need a local IDE or write routine code by hand.
Run agents in parallel cloud workspaces where they can implement, test and review without depending on your laptop. Give each task a reproducible environment and only the access it needs.
Be selective about reading code.
Read API contracts, database changes, authentication logic and mission-critical code when a decision needs your judgment. Let automated checks and agent reviews cover routine implementation.
Use system maps, data models, performance traces and review reports to assess the design.
Keep trying to break it.
Have agents attack staging 24 hours a day, seven days a week.
Let them explore user journeys, fuzz inputs, test permissions, interrupt dependencies and probe performance limits. Use isolated test data and cap resource use.
Keep watching after deployment.
Agents should watch deployments, logs, errors and latency, trace regressions to changes, and propose fixes. Test those fixes in staging and check that recovery worked.
- Agents can act
- Let agents handle known repairs within agreed permissions, using the same release checks as new features.
- Humans decide
- Bring uncertain root causes, design changes, sensitive data decisions and actions beyond agreed authority to a human.
START HERE / ONE REAL SYSTEM
Build your first factory.
Choose one troublesome user journey. Agree on the product and technical design, then have agents build and independently test an MVP within a week. Let product try it and decide what comes next. Track delivery time, escaped defects and how often someone has to intervene.