When Code Becomes Cheap, Design Becomes Critical
Coding agents answer the hard design questions by default, and differently each time. A letter on what an architecture review of forty generated adapters should ask.
Written as at 3 August 2026.
software-architectureai-engineeringdesignproductivityletters
You may recognise the shape of your week. The review queue is longer than it was a year ago, the pull requests are tidier, and more of them were drafted by a coding agent than by the person whose name is on them. You approve more than you used to and read less of each one. Nothing has broken yet.
Illustrative scenario: a fictional composite written to make the point concrete. It does not describe a real organisation, and its figures are not reported outcomes.
Imagine a platform team in that position. In one sprint, working with coding agents, it produces forty integration adapters connecting a new agent platform to the CRM, the ERP, the HR system, ticketing, two payment providers and a long tail of line-of-business applications. Each adapter compiles, each ships with tests, and every test is green. The demo earns its applause.
Now imagine the architecture review that ought to follow the demo. Its questions are not about code quality, and the forty adapters answer them badly.
The first question is what happens when a call fails halfway, and three adapters picked at random give three answers. One retries without limit and without backoff. One retries three times on everything, including the request that creates a supplier, so a single timeout can leave the ERP holding the same supplier twice. The third has no retry at all and passes back whatever the provider returned.
The second is whose credential each call uses, and who granted it. The review finds a token cached for the life of the process, a shared secret read from an environment variable because a sample did it that way, and one adapter running under an account with far more access than its task needs.
The third is what each call leaves behind that someone could check next month. Mostly it is a log line, in forty formats, with nothing tying the change in the target system back to the request that caused it.
The fourth is what each adapter is allowed to see. The one that updates a customer’s delivery address fetches the whole customer record, payment details included, because that was the simplest endpoint.
Notice what the review has uncovered: all four questions were answered during the sprint. Nobody chose the answers: the generator supplied a plausible default each time, and it supplied forty different defaults. Cheap code does not skip the design decisions. It takes them quietly, one component at a time, and leaves you to discover their sum in production.
Does this show up beyond one team? DORA’s 2024 research associated each 25 per cent increase in AI adoption with 1.5 per cent lower delivery throughput and 7.2 per cent lower delivery stability. Its 2025 report found adoption linked with higher throughput but still with instability, and described AI as an amplifier of whatever an organisation already is.
None of that means the individual gains are imaginary. Cui and colleagues’ field experiments with 4,867 developers at three companies found about 26 per cent more completed tasks, with the largest gains among less experienced developers. METR’s much smaller study is a warning about judging any of this by feel: 16 experienced open-source developers working on 246 issues in code they knew were 19 per cent slower with AI tools allowed, after forecasting they would be 24 per cent faster, and afterwards believed they had been 20 per cent faster.
So what should the review ask for instead? John Ousterhout’s idea of a deep module is the most useful test I know. Ask what a caller must understand to use adapter seventeen safely. If the honest answer includes its retry habits, its token handling and its error format, then its interface is as wide as its implementation, and forty such adapters are forty sets of habits that every caller and every operator has to learn.
The deeper design is one integration module that holds the four answers once: which failures may be retried and how a repeated request is recognised, which narrow and short-lived credential each call carries, what record every call writes, and what data each purpose may ask for. Behind it sit forty thin mappings from your canonical business objects to each system’s fields. That mapping is exactly the work coding agents do well, so let them do it in volume.
The stakes rise as the callers become agents. An adapter that an agent can invoke is the route by which a model’s proposal becomes a changed record in a system you answer for. The review questions stop being hygiene: they decide what the agent can see, whose authority it spends, what evidence survives and how much harm one bad retry can do. Those answers come from your organisation’s obligations, so they have to be written down by people who know them.
My forthcoming book sets out the Contextual Agentic Enterprise (CAE), a vendor-neutral architecture and operating model for letting people, models, agents and systems act together under explicit authority, with evidence. A good part of it is about settling these questions before an agent is allowed to call anything.
To engineers early in their careers reading over someone’s shoulder: generated code has not devalued your judgement. What has become scarce is the ability to say what a component must not see, must not do and must always record. Say it out loud in design reviews until it comes easily.
On Monday, try three things. Replace lines of code, pull requests and adapters per sprint on your dashboard with change failure rate, rework and time to restore service. Put the four review questions to your own version of the forty adapters, count the distinct answers, and set a target of one each. And make it a review rule that a new component must reduce total complexity, shown by a short boundary statement and a contract test that fails when the boundary is breached.
Sources
- Becker, J., Rush, N., Barnes, E. and Rein, D. (2025) “Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity”, METR, arXiv:2507.09089. https://arxiv.org/abs/2507.09089
- Cui, Z., Demirer, M., Jaffe, S., Musolff, L., Peng, S. and Salz, T. (2025) “The Effects of Generative AI on High-Skilled Work”, Management Science. https://pubsonline.informs.org/doi/10.1287/mnsc.2025.00535
- DORA (2024) Accelerate State of DevOps Report. https://dora.dev/research/2024/dora-report/
- DORA (2025) State of AI-assisted Software Development. https://dora.dev/dora-report-2025/
- Ousterhout, J. (2021) A Philosophy of Software Design, 2nd edn, Yaknyam Press.
- The Contextual Agentic Enterprise, Introduction, Chapters 9 and 22.
This article is part of Letters from the Contextual Agentic Enterprise, a series accompanying the forthcoming book, The Contextual Agentic Enterprise.
Related
From Assistance to Agency: Why Enterprise AI Creates a New Architectural Problem
Letting a service desk assistant reset MFA is not phase two of the same programme. Once an agent can change state, the question becomes what it may change, and on whose authority.
A Model Can Recommend an Action. It Does Not Acquire Authority to Perform It
Directors ask whether their AI is safe. The better question is on whose authority it acts, because accuracy, confidence and technical access are not a delegation.
When Code Is Cheaper, Delivery Still Has a Cost
Faster code generation changes delivery economics, but requirements, verification and operational outcomes still need attention.