The request I hear most often now goes like this: a feature that used to take a month, and someone wants it in two days, because "the AI writes the code now."

It isn't only the people I work with. A developer on r/cscareerquestions asked other engineers how much AI had really sped them up, and put it plainly: "i don't think the 2x, 5x, 10x productivity gains leadership expects from us are actually possible at this point in time." The thread has more than 50 replies, and they don't agree on a number.

I use coding agents every day and I like them. They do type faster than me. But the month was never mostly typing. Most of it went to keeping the code in a shape the next person can work with, and that part didn't get faster. In some places it got harder, because the agent produces more code for me to keep in shape. This post is about where the month goes now that typing is cheap, and the checks I added so the agent stops bending the architecture.

1. The agent calls the API again instead of using the layer you built

Left: three features each calling the external API directly. Right: all features go through one API client, and fetch or axios outside it is a lint error

Ask an agent for a feature that needs data from an external API and, often, it calls the endpoint directly, sometimes several times, instead of going through one facade. Left unchecked, every prompt solves its ticket with its own HTTP call, its own retry logic and its own error shape. On r/ClaudeAI, someone asked how to deal with exactly this: "The AI keeps writing the same functions over and over again instead of reusing existing ones."

To stop that in my repos, I list every existing API client in AGENTS.md (or CLAUDE.md), and in plan mode I ask the agent to name the client it will reuse before it touches code. Even then, a markdown rule drifts over a long session. In another r/ClaudeAI thread, the agent did look for existing code and still picked the wrong one, and one reply put it in five words: "Prompting is praying, verification is a guarantee."

What helps:

  • Name the boundary in a file the agent reads every time. One line beats a paragraph: "External HTTP calls only go through src/services/clients/."
  • Make crossing it fail the build. A lint rule turns "please use the facade" into an error the agent sees and fixes on its own. A sketch with ESLint:
// eslint.config.js export default [ { rules: { "no-restricted-globals": ["error", { name: "fetch", message: "Use the API client in src/services/clients." }], "no-restricted-imports": ["error", { paths: [{ name: "axios", message: "Use the API client in src/services/clients." }] }], }, }, { files: ["src/services/clients/**"], rules: { "no-restricted-globals": "off", "no-restricted-imports": "off" }, }, ]; 

When I review the diff, the first question is whether this already exists somewhere. Tests catch bugs. They rarely catch a second API client.

2. Every new table forgets the columns every table has

Left: the CREATE TABLE the agent writes with only the requested fields. Right: the standard columns every table should have, checked in CI

When I model a new table with an agent, it gives me the columns I asked for and nothing else. The ones every table in the project has, the ones nobody mentions because they're the convention, aren't there. Someone filed this exact pattern as an issue on the Claude Code repository in July 2026: the model wrote CREATE TABLE "with only the fields it can infer from context", deployed, and called it done. The missing fields showed up later as broken screens, "sometimes 4-6 times for the same data type."

From the agent's side it makes sense, since the convention lives in the team's heads and never made it into the prompt. So before any schema work I give it the conventions and one existing table as the example, and I read every migration before it runs. What holds up over time is putting the convention in code the agent has to call, like a base model or a migration helper that already adds the standard columns, and checking it in CI. For Postgres, a sketch:

-- Fails the check if any table in the public schema has no created_at column SELECT t.table_name FROM information_schema.tables t WHERE t.table_schema = 'public' AND t.table_type = 'BASE TABLE' AND NOT EXISTS ( SELECT 1 FROM information_schema.columns c WHERE c.table_schema = t.table_schema AND c.table_name = t.table_name AND c.column_name = 'created_at' ); 

If the query returns rows, the check fails and the agent gets the table name.

3. Design consistency is still the hardest part

Left: rules written as prose in CLAUDE.md, and the output drifts from the spec. Right: tokens, components and a reference screen enforced by lint and types

Getting an agent to follow a design, and keep following it across screens, is still where I struggle the most. On r/UXDesign, someone asked how to get Claude Code to follow design specs: "I have built a skill, updated my CLAUDE.md multiple times, and still cannot get it to follow my figma specs." One reply suggested a design token store the model can read, plus "some kind of deterministic linting system wrapped around the generation process."

Alice Moore at Builder.io makes the same argument at length, and sums it up as "Because prose always loses to code."

I learned the same thing outside of UI. I have a long list of writing rules for my own posts, and I ended up turning them into a script that checks every draft. The script does what the list in my prompt couldn't, and it also taught me its limit: it checks form, so it says nothing about whether a fact is true.

On the UI side, I give the agent one finished screen as the reference and compare every new screen against it before I accept the change. Agents copy what's nearby, so that screen does more than a page of instructions. The rest goes into lint: colors and spacing as named tokens, so a hex value in a component is an error, and the project's own <Button> instead of a raw <button> in a feature folder.

4. The two-day expectation

Two bars: writing the code got faster with an agent; deciding, reviewing and testing stayed about the same or grew

Here's where the problems meet. From the outside, the agent looks like it does the month of work in an afternoon, and in a demo it does. What the demo doesn't show is the review: finding the second API client, adding the missing columns, pulling the screen back into the design system. Sean Goedecke described the gap in a post from July 2025: "The problem is that tech leaders are expecting a consistent 10x speedup, not the 1.5x speedup I'm getting."

Saying "it won't be two days" sounds like resistance. Showing where the time goes lands better. The same r/cscareerquestions thread has the clearest description I've seen of why: one reply said that on a simple feature, AI can feel like "10x productivity", and when you hit a problem the AI can't handle, it takes about 50% longer than doing it yourself. A feature is rarely all simple parts, and the estimate has to cover both.

A message you can adapt:

Here's how I'd estimate this feature with AI in the loop: - Writing the code: faster than before. With an agent this part is [X days]. - Deciding the data model, the API boundaries and the screens: the same as before, [Y days]. The agent doesn't make these decisions well on its own, and fixing a bad one later costs more than making it now. - Reviewing and testing what the agent wrote: [Z days]. This part grew, because there's more code to check. So the realistic total is [X + Y + Z]. If we need it sooner, here's what we can cut from scope: [...] 

The last line matters most, because it gives the person a choice between time and scope.

How I'd run the next feature

  • Write down the boundaries before the agent starts: where API calls live, what every table needs, which components to use.
  • Turn each boundary into something that fails: a lint rule, a CI check, a type.
  • Point the agent at one good example in the codebase.
  • Review the diff for "does this already exist?" before "does this work?"
  • Estimate in two numbers, writing and deciding, and say both out loud.

Sources