Thoughts on the New Coding

Talking to friends, I’m realizing there are a decent number of people who either aren’t reviewing agent-written code at all, or are just having another agent review it.

Maybe it’s fine

This is probably fine for side projects, throwaway prototypes, or one-off commands in bigger repos that can be tossed at any time. Maybe it’s yet another argument for microservices.

Agents are pretty good at avoiding and catching simple bugs: nil panics, obvious logic goofs, that kind of thing.

But what about code that needs to keep growing for a year?

Did it actually do what you wanted?

I’ve seen agents take shortcuts to make things “work.” Maybe they return a hard-coded string that makes it look like progress is happening.

But they can also take long cuts: building whole data-storage models when a simple link would have worked.

How are you testing the changes? Are you manually walking through each one? Do you have end-to-end tests? Who reviews the end-to-end tests?

Did it compromise the code to get there?

Did it add three if statements when one would have made more sense? Did it sling more code into the file that’s already 1,000 lines long? Are all your members public now?

When do agents stop and make interfaces? Why not just couple everything together by passing 10 concrete objects as inputs, especially when the agent can type faster than any human?

Many engineers never cared about this stuff in the first place. But I thought we had all agreed those were no-hires.

Am I wrong?

We’ve had capable coding agents for, what, four months?

Maybe architecture can be encoded in an AGENTS.md file, but I’m doubtful. It’s more possible that GPT-6 and whatever comes next will simply be much better at architecture. But I’m not so sure.

My current prediction: we’ll see a lot of projects start collapsing under their own weight in the next 6–12 months.

Original notes from May

• Most people never cared how the sausage was made.
• Are you reviewing your code? At what rate is debt growing?
• Microservices are going to do much better than monoliths.
• Your codebase is the best example.
• Are we all just testers now?
• How should agents coordinate if we actually parallelize?
• Is this just being a Luddite?
• Will the next generation of models blow all these concerns away?

This post was copyedited by chatgpt

Related links

• Pro Review presentation: https://x.com/geoffreylitt/status/2072522251300409556

• Moustache officiando on progrmattic engineer podcast thinks it collapses after coule of months without review https://newsletter.pragmaticengineer.com/p/context-engineering-with-dex-horthy. But also says what about gpt 7. Also alot more from him here including with opus 5 https://www.linkedin.com/pulse/why-software-factories-fail-dexter-horthy-ttxae/

• Uncle Bob thinks you can’t review to keep productivity gains but claims lots of test coverage that its unclear who writes/designs that https://x.com/unclebobmartin/status/2080257779395154409?s=46&t=OzkNidEU6S4JXK3XrsUANQ and https://x.com/unclebobmartin/status/2080279364592119978?s=20. Also this led me to bob’s https://github.com/unclebob/crap4java and then to https://github.com/padiazg/go-crap.

• Armin Ronacher — 90% — Uses AI for roughly 90% of the code but says he still reviews every line, shapes the architecture, and treats the result as his responsibility.

• Simon Willison — Parallel coding agents — Argues that AI-generated code still needs human review, making review speed a key bottleneck even when agents can work in parallel.

• Mitchell Hashimoto — My AI Adoption Journey — Says he will not ship code he does not understand and emphasizes thorough manual review for serious, long-lived software.

• Peter Steinberger — “I ship code I don’t read” — Explicitly says he sometimes ships agent-written code without reading it, relying more on architecture, tests, and verification, while applying more scrutiny to critical code.

• David Heinemeier Hansson (DHH) — Promoting AI agents — Describes increasingly reviewing the final outcome of agent work rather than necessarily inspecting every implementation detail, while still enforcing quality and architectural cohesion.

• Cat Wu and Thariq Shihipar / Claude Code team — Simon Willison interview — Say Anthropic does not require human review of every production change; critical areas still get manual review, while validated AI review can handle some lower-risk code without human approval.

• Martin Fowler — Agentic Programming — Distinguishes agentic programming from pure “vibe coding,” arguing that humans using agents should still remain concerned with and often review how the software actually works.

• Charity Majors — LinkedIn post on AI and validation — Argues that the real bottleneck with AI-generated software is not traditional code review but validation: tests, observability, and evidence that the system behaves correctly.