Leading engineering teams that code with AI
What changes when AI writes most of the code: review becomes the bottleneck, technical debt costs more, and someone has to decide what the agent prefers.
When AI writes a large share of the code, the work of an engineering team moves. Producing code stops being the scarce part. Reviewing it, understanding it and deciding what the agent should prefer become the job.
That shift shows up in places leaders do not always look. Review queues grow while output charts look healthy. Old, accepted risks in the codebase get more expensive because AI makes them easier to find. Release dates slip because bugs are found faster than they can be fixed. And an agent makes stack and library choices at machine speed, often from defaults nobody in the company chose.
These posts are written for CTOs and engineering managers who are past the question of whether to adopt coding agents and are now dealing with what happens after.
The posts, in reading order
-
Writing code got free. Reviewing it is the job now.
Microsoft's engineers merged 24% more pull requests with AI. The constraint didn't vanish; it moved to review, and most teams are still counting the wrong thing. -
AI Writes the Code. Who Governs It?
Almost every team now codes with AI; only a third governs it. The teams pulling ahead review AI's output as seriously as they once reviewed their own code. -
AI turned every engineer into a manager. Nobody trained the managers.
Working with AI feels like managing a fast junior developer. But you can only delegate what you can verify, and the agent never grows into someone who can check the work for you. -
AI just raised the interest rate on your technical debt
A crash bug sat unfixed for two years until AI turned it into remote code execution. Your list of accepted risks was priced for attackers who no longer exist. -
Your release date assumed bugs were hard to find
Postgres 19 slipped after AI found old bugs faster than maintainers could review the fixes. Plan your roadmap around verification capacity, not discovery. -
Pick the stack that catches your AI's mistakes
A popular claim says exotic languages save tokens when AI writes your code. On real tasks that edge disappears, and the number worth optimizing is the cost of being wrong. -
Your coding agent has a default stack. Who chose it?
Developers have always picked libraries by taste and familiarity. Now an agent makes those calls at machine speed, and most companies have never written down what it should prefer. -
Your coding agent now takes instructions from your software vendors
A desktop app updated itself and wrote startup instructions into its users' Codex and Claude Code. Agent configuration is now a procurement and governance question. -
When code gets cheap, your abstractions get expensive
Shopify's return to native Swift and Kotlin looks like an AI story. It's really a lesson in why the efficiency layers in your stack may no longer earn their cost. -
AI just put a price on clever code
Google's case for Go is really a case against magic. When a model reads and rewrites your code, legibility stops being a matter of taste and starts showing up in the budget. -
The code you can't explain
AI agent loops have made code fast and cheap to generate. The hard part, knowing what to build and staying in ownership of it, is still entirely yours. -
Anthropic replaced git because git assumes a human is typing
Merges grew tenfold in five months and source control became the bottleneck. The lesson for other companies is to find which of your tools still assume a person is the user. -
Your backlog is the only benchmark that matters
Public coding benchmarks have decoupled from real work. The teams getting value from AI build a small evaluation from their own merged pull requests instead.