The New Agency AI Stack Turns Code Review Into the Real Production Gate

Two years ago, agencies kept AI coding tools away from client work and let junior developers experiment with them on internal projects instead, the kind of code where nothing broke if it was wrong. Dev shops that used to quote four to six months for a minimum viable product now quote six to twelve weeks for the same scope, often starting around $30,000, according to a July 24 report from freeCodeCamp. The compression is not coming from cutting review out of the process. It is coming from a three-layer AI coding stack that agencies have converged on almost by default, paired with a code review discipline that has gotten stricter, not looser, as the tools got faster.

That shift sits inside a wider contradiction. Adoption of AI coding tools keeps climbing: the 2025 Stack Overflow Developer Survey found 84 percent of developers were using or planning to use AI tools in their development process, up from 76 percent a year earlier, and 51 percent of professional developers now use AI tools daily. But trust in what those tools produce is moving the opposite direction. The same survey found 46 percent of developers actively distrust the accuracy of AI-generated code, versus just 33 percent who trust it, and only 3 percent report “highly trusting” the output. Agencies that ship AI-assisted code to paying clients are the ones stress-testing that gap in production every week, and the freeCodeCamp report is a detailed look at how they are managing it without it turning into a liability.

The Three-Layer Stack Agencies Actually Run

Per the freeCodeCamp report, most agency AI stacks now split into three distinct layers, and the split is not incidental. Each layer does a job the other two are bad at.

Layer 1: Chat Assistants for Planning, Not Typing

The first layer is the chat assistant, the report names Claude and ChatGPT specifically, used for planning, architecture questions, and debugging rather than writing code directly. A senior developer might paste an error log and get several likely causes back in seconds, or describe a feature and ask the assistant to surface edge cases that had not been considered yet. This layer is about thinking through a problem before anyone touches an editor.

Layer 2: The AI-Native Editor for Multi-File Work

The second layer is the AI-native editor, where the report says Cursor leads. Unlike a chat window, this tool wraps a full code editor around a language model that can see an entire codebase rather than a single open file. Engineers use it to write new features, refactor existing code, and generate tests, and its agentic modes can now carry a task across many files at once while the engineer reviews each step along the way.

Layer 3: Inline Completion for the Repetitive Parts

The third layer is the inline assistant, with GitHub Copilot as the best-known example. It lives inside the editor and completes code as a developer types, handling boilerplate, repeated patterns, and standard functions. It is the least dramatic of the three tools, according to the report, but it runs constantly, and the small time savings compound over a full workday.

Most shops the report describes run all three layers at once: the chat assistant plans, the AI-native editor builds, and the inline assistant fills in the gaps between them.

What Changed Operationally: Faster Builds, Stricter Reviews

The freeCodeCamp report is explicit that the speed gain does not come from letting AI-generated code ship unsupervised. The pattern it describes is a tight loop: an engineer breaks a feature into small tasks, the AI drafts code for each one, the engineer reads every line, fixes what is wrong, runs the tests, and only then does the change go through the same pull request review that human-written code has always gone through. The report’s framing is blunt about where teams get burned: the ones that skip the review step. AI-generated code can look correct and run cleanly in a demo while still hiding weak error handling, security holes, or database queries that only fall over once they hit real load. A demo does not catch those problems. A senior engineer reading the diff does.

That review discipline is also where the economics show up. Fixed-scope, fixed-price MVP offers are back in fashion, the report notes, because AI makes timelines more predictable for well-defined work. AI tools are also particularly strong at the tasks engineers tend to avoid, like writing tests, documenting code, and updating stale dependencies, so codebases built this way often ship with better test coverage than hand-built projects did five years ago, simply because tests now cost far less to produce. The tradeoff is a new line item: heavy agentic use racks up real token costs, on the order of hundreds of dollars per engineer per month, according to the report. For an agency, that is still cheap against a salary, but it is a cost center that did not exist before.

The Trust Gap Behind the Adoption Numbers

The Stack Overflow survey data explains why the pull request review step has not gone away even as the tools have improved. Adoption and trust are not moving together. Developers are using AI tools more than ever, but a shrinking share of them believe the output is reliable without a human checking it first. Only 3 percent of respondents said they “highly trust” AI-generated code, while 46 percent said they actively distrust its accuracy. That gap is precisely what a strict review gate is designed to absorb: it lets a team capture the speed of AI-assisted drafting without needing to trust the draft.

It also explains why the three-layer stack looks the way it does. The pattern the report describes does not treat the AI-native editor’s agentic mode as a replacement for a human decision-maker: the engineer reviews each step as the agent works across files, rather than letting it run to completion and grading the result afterward. The chat assistant is used for the same reason, as a way to pressure-test a plan or catch edge cases before code gets written, not to hand off decisions the assistant cannot be held accountable for.

A New Market: Rescuing Software That AI Built Alone

The clearest evidence that the review step matters is the market forming around teams that skipped it. The freeCodeCamp report singles out Empat, a dev shop with offices in San Francisco, London, and Kyiv, which offers what it calls “vibecode rescue,” a service for founders who built an app using AI tools and hit a wall. Empat’s own site confirms the offering and is specific about what it covers, describing work with “AI-native products, AI-enhanced platforms, and broader software products where AI features, generated code (e.g. from Lovable, Cursor, Bolt, or other AI-coding tools), or unstable integrations create delivery and scaling problems.”

The freeCodeCamp report’s read on this is straightforward: the app works until it does not, and then someone has to go back in, untangle the code, add tests, and make it stable. AI makes building easy. It does not make building well easy, and the gap between the two is now large enough to support a specialized line of consulting work.

What This Means for Teams Buying or Building an AI Coding Stack

For a team evaluating an “AI-powered” agency, or deciding how to structure its own internal AI coding stack, the operational details in the freeCodeCamp report point to a few concrete questions worth asking before signing off on either one.

• Does the review step survive contact with a deadline? The failure mode described in the report is not the AI tooling itself, it is a team skipping the human read-through when a deadline gets tight. Ask whether code review is a gate that can be waived under pressure or a hard requirement enforced by process, such as required pull request approvals before a merge is even possible.
• Who is accountable for a specific change? A named engineer should own every merge, the same way they would for hand-written code. If no single person can explain why a given change is safe, the review step is theater rather than a real control.
• Is the token cost visible, or hidden in the quote? Heavy agentic use has a real, ongoing model-usage cost. A fixed-price quote that does not account for it is either underpricing the work or planning to cut corners somewhere else to make the number work.
• What happens to test coverage and documentation? Since AI tools are comparatively good at the tasks engineers usually skip, a codebase that comes out of this stack with thin tests or no docs suggests the team is using the tools to go fast rather than to go well.

None of this requires distrusting AI coding tools outright, and the adoption numbers show most developers are not going to stop using them. It requires treating the review loop as the part of the stack that actually earns the trust the tools themselves have not yet earned on their own, which is exactly how the agencies in the freeCodeCamp report describe running production work today.