"It wrote enough slop that eventually it collapsed into an incoherent, unmaintainable mess."
That's Adam Jacob describing what happened when he relied on AI coding agents to build complex prototypes without maintaining engineering discipline. His argument, laid out in a March 29 blog post, cuts through both sides of the AI coding debate: the people who dismiss AI agents as junk producers AND the people who insist you're falling behind if you're not using them constantly.
Both camps miss the point, Jacob says. AI doesn't remove the need to engineer. It moves your job from the code level to the architecture level.
Your Job Is to Augment the Agent, Not the Other Way Around
Jacob's mental model flip is worth sitting with. Most developers think of AI as a tool that augments their workflow. Jacob argues the framing should be reversed: your job is to build the machine that lets the agent produce good software.
He gives a concrete example. He needed to configure DigitalOcean's S3-compatible storage as a backend for his product, Swamp. He asked Claude to handle it. The agent missed 4 out of 10 places in the codebase where an S3 client was created, producing a brittle implementation that would break under real use.
The fix wasn't to manually patch those 4 spots. It was to tell the agent to refactor - to find the structural seam where the code was factored wrong and fix it at the architecture level. Once the code was properly organized, the agent could handle the S3 integration correctly because there was only one place to change.
Faster Loops, Not Fewer Fundamentals
The speed of AI code generation doesn't eliminate refactoring cycles. It compresses them. Jacob's point: because agents produce code so fast, the refactoring loop tightens too. You're not spending less time on architecture decisions. You're making more of them, faster.
But existing development processes break down here. They assume the human understands every line of code. When an agent writes thousands of lines in minutes, that assumption falls apart. Jacob's solution is to build adversarial loops: update architecture documentation that guides the agent, run automated DRY reviews (checking for duplicated logic), and rely on external black-box tests that verify behavior without requiring you to read every line.
This matches what we see daily testing AI coding tools. Cursor, Claude Code, GitHub Copilot - they all produce working code fast. The bottleneck is never generation speed. It's whether the generated code fits into a coherent, maintainable system. That's still a human engineering problem, and it will be for a while.
The fundamentals are the fundamentals. They just happen faster now.