AI-approved code ships five times faster with fewer reverts

Let me catch you up. The people getting real work out of AI coding agents are not the ones with the best prompts. They are the ones who built a system around the agent first. A contract it reads. A loop it follows. Checks it can run without you. And a few teams are already letting AI review AI-generated code in production, faster and with fewer reverts than humans. That shift changes what your designers and PMs need to know how to do. Here's where we are.

The deep cut

• The setup outranks the prompt. An empty repo makes Claude Code drift; a written contract and loop make it sharper each session.
• Speed hides bad judgment. Jake Albaugh calls the surrender to polished output "cognitive surrender," where you adopt the model's take as your own.
• Let the risk score decide who reviews. Intercom's AI-approved PRs ship five times faster with a lower revert rate than human ones.

The empty repo is the problem, not the model

Open a fresh repo, ask Claude Code for a feature, and it works. Ask for the next one, and it drifts. Inconsistent structure. Decisions relitigated every session. A reviewer that is the same model that wrote the code.

The reflex is to write a better prompt. That is the wrong lever. One Towards AI walkthrough frames the fix as building an operating system for the project: a CLAUDE.md contract the agent reads first, a repeatable per-feature loop, and living Markdown boards for status, risks, and open questions. Agents do not hold context between sessions. Anything not written down gets reinvented.

The load-bearing rule is small: a feature is not done until its docs are updated. That is what stops the drift. Do the setup once, and every session after runs inside rails you chose.

Fast is not the same as right

When anyone can ship working software, picking the right thing to ship gets harder. Figma's Jake Albaugh names the trap: we trust polish because it used to reflect hard decisions. Now the model fills the gaps and hands you something that looks great and falls apart under the hood.

His sharper point is what he calls "cognitive surrender." You stop asking "what should this be?" and start asking "which of these is least wrong?" Models pull toward the average of what already exists. Ask for a logo, get a geometric mark with a gradient. Accept it enough times and your own judgment narrows to match.

For a design leader, this is where your team's edge lives. A strong design system gives agents a precise vocabulary and clear guardrails, which means consistent output and less debt. The point of view still has to be yours.

Let the risk score decide who reviews

Here is the move that will feel reckless and is not. On the How I AI episode, Claire Vo built an agent that reads each pull request, scores its risk, auto-approves the safe ones, and sends the questionable ones to Slack. She built it in one Codex session using Vercel's Eve, from a two-sentence prompt.

The engine is a risk model. It scores each PR across six dimensions: size, blast radius, reversibility, data and security, operational impact, and whether tests and CI actually ran. Under 24 points, the agent clears it. Over 64, a human takes it. The exact numbers matter less than turning a judgment call into a repeatable rule.

Intercom already runs this at scale. Its AI-approved PRs move five times faster than human-reviewed ones with a lower revert rate. The safeguards that keep it honest: log every decision, keep the audit trail queryable, and have an engineer eval the scores. Evals are what keep the agent trustworthy after the novelty wears off.

The interface stops being the front door

One CTO reports that more than 95% of the code he ships was not typed by him. His next call: the next generation of SaaS will be agent-first. The product keeps its database, permissions, and business rules. The app screen stops being the only way in.

Picture asking an agent to schedule an article for Wednesday at 9 a.m. It notices a conflict and shows your editorial calendar right inside the conversation, so you can decide. You never opened the tool. The interface still appears, but only when a human needs to see a state and approve. For your team, this means designing for the moment a human decides, not just the moment they click.

The setup is a skill now

Grace Clarke rebuilt her whole service business on three Claude skill files: a pipeline operator, a proposal maker, and a voice guide that teaches Claude how she thinks. She calls the shift "intent engineering" over prompt engineering. She does not craft the perfect prompt. She explains the problem, describes the outcome, and asks Claude to come back with a proposal.

The plainest daily habits echo across the sources: speak the full brief instead of squeezing it into a terminal, and give the agent a check it can run without you. And separate the coder from the reviewer. An agent grading its own homework misses the same blind spots twice.

Three questions for your team

• What is our CLAUDE.md contract, and who keeps it honest when the stack changes? If nobody owns it, the agent follows a stale file over your intentions.
• Where is our risk line for auto-approving AI-generated PRs, and can we defend the audit trail to security? Copy Intercom's discipline: log every decision and eval the scores.
• Which of our products would we redesign if the agent, not the screen, were the default way in? Start with the one job users open your app to do and never enjoy doing.