Fast to Generate, Slow to Trust: The 1:24 Ratio

Reco.ai published a blog post with a headline designed to impress: “We Rewrote JSONata with AI in a Day, Saved $500K/Year.” The numbers are real. So is the part buried in paragraph twelve.

The AI generation took seven hours. The verification took a full week.

Seven hours of prompting produced 13,000 lines of Go, a complete reimplementation of the JSONata 2.x specification. Cost: $400 in tokens. The code passed 1,778 test cases. It compiled. It ran. And then the real work started.

Reco’s team ran the output against 2,107 production integration tests. They deployed gnata, their open-source result, in shadow mode alongside the existing JSONata implementation, evaluating every expression against real production traffic. Billions of events, thousands of distinct expressions. They logged mismatches. They fixed edge cases. They waited for three consecutive days of zero mismatches before promoting gnata to primary.

The generation-to-verification ratio was roughly 1:24. For every hour the AI spent writing code, the team spent twenty-four hours building the trust to ship it.

The $500K headline, unpacked

The savings claim deserves scrutiny. Reco bundles two separate projects: the JSONata rewrite, which eliminated around $300K per year in Kubernetes compute by replacing jsonata-js pods with a native Go implementation, and a separate rule engine refactor that saved an additional $200K or so. The “1000x speedup” on common expressions comes partly from eliminating RPC overhead between services, not purely from better code.

None of this makes the project less impressive. It makes it more instructive. The honest version of the story is better than the headline version. A team with deep domain knowledge used AI to generate a first draft of a complex language reimplementation, then spent a week building the evidence that the draft was production-worthy.

That ratio, generation fast and verification slow, is the pattern every engineering organization should be studying.

The constraint hierarchy

Will Larson published “Judgment and creativity are all you need” in March 2026. Larson is the CTO of Imprint, formerly at Stripe, and the author of Staff Engineer, a book that shaped how the industry thinks about senior technical roles. His argument is structural, not aspirational.

Larson describes a constraint hierarchy for software engineering in 2026: Time, then Attention, then Judgment, then Creativity. Each constraint only becomes binding after the one above it is solved.

Coding agents solved the Time constraint. Writing code is fast now. But speed created a new problem. Larson’s team at Imprint spends almost all their time on two activities: designing approaches and reviewing agent pull requests. When a design doesn’t survive contact with reality, they revise and iterate. The actual typing of code is a rounding error.

This matches the Reco.ai data precisely. The seven hours of generation solved the time constraint. The week of verification was the judgment constraint asserting itself.

Faster code production does not mean faster delivery, and Reco’s numbers put a price on the difference. The generation cost $400. The verification cost a week of senior engineering time. In any reasonable accounting, the verification was the more expensive phase by an order of magnitude.

Larson goes further. He argues that expert context packages for coding agents represent the mechanism for scaling judgment itself. The industry is building skill repositories for agents: shared configurations, domain-specific rules, architectural patterns encoded as agent instructions. This is judgment as infrastructure. It is also, whether Larson uses the word or not, governance.

Coding guidelines are governance documents

The same week, Stack Overflow published “Building shared coding guidelines for AI (and people too).” The piece gathers enterprise leaders who converge on a single operational insight: coding guidelines for AI agents are governance infrastructure.

Charity Majors, CTO of Honeycomb, has been making this argument for years in the context of observability. Quinn Slack, CEO of Sourcegraph, has built tooling around code intelligence. Vish Abrams, Chief Architect at Heroku, works at the infrastructure layer where bad code becomes expensive fast. Logan Kilpatrick speaks from Google DeepMind’s perspective on agent capabilities.

Their consensus: when agents write most of the code, the standards those agents follow become the primary quality control mechanism. A style guide is no longer a suggestion for junior developers. It is a constraint layer for autonomous systems.

The pattern started small, with individual teams encoding their conventions into agent instruction files. Now CTOs of billion-dollar companies are describing the same mechanism for production codebases. The mechanism is identical. The stakes are higher.

The 1:24 ratio and what it means

The Reco.ai story is valuable because it gives us a concrete number for something the industry has been discussing in abstractions. One hour of AI generation requires twenty-four hours of human verification. Call it the 1:24 ratio.

Is this ratio universal? No. Simple CRUD applications probably have a lower verification burden. Safety-critical systems probably have a higher one. But the order of magnitude is instructive. Even in a best-case scenario, with an experienced team, a clear specification, an extensive test suite, and open-source transparency, the verification phase dominated the project timeline by a factor of twenty-four.

Industry data supports the pattern at scale. Sonar’s State of Code 2026 survey of 1,149 developers found that 96% don’t fully trust AI-generated code. Only 48% verify outputs before committing. Faros AI, studying telemetry from over 10,000 developers across 1,255 teams, found that PR review time increased 91% in teams with high AI adoption.

The developers are rational. They know the code needs checking. Many of them skip the checking anyway because the verification infrastructure doesn’t exist at their organizations. The code arrives faster than anyone can evaluate it. Larson’s constraint hierarchy explains why: most organizations haven’t recognized that judgment, not generation, is where they should be investing.

What the convergence reveals

Three independent sources, published within the same two-week window, none citing each other, arriving at compatible conclusions. Reco.ai provides the data. Larson provides the theory. Stack Overflow provides the enterprise consensus.

The synthesis:

Generation is solved. The cost of producing code dropped to near-zero. This is no longer news. It is an accomplished fact.

Verification is the bottleneck. The cost of confirming that generated code is correct, safe, performant, and aligned with organizational standards has not dropped. In many organizations it has increased, because the volume of generated code overwhelms existing review capacity.

Judgment is the last constraint. Once you can generate code instantly and verify it systematically, the remaining constraint is deciding what to build, how to build it, and whether the result serves the actual need. Larson calls this judgment. The Stack Overflow experts call it coding guidelines. They are all describing the same capability: the ability to evaluate whether generated output is good.

Trust needs infrastructure to scale. An individual developer with deep expertise can evaluate AI output. An organization with hundreds of developers cannot rely on individual expertise. It needs systems: coding standards encoded as agent constraints, verification pipelines that match generation throughput, review processes that focus human attention on judgment calls rather than syntax.

The investment implication

Most organizations are investing in generation. Better models, faster agents, more tokens, broader coverage. This is optimizing the seven-hour part of a week-long process.

The organizations that will win are investing in verification. Test infrastructure that scales with generation volume. Shadow deployment systems like Reco’s that validate AI output against production reality. Coding guidelines that function as governance documents. Review processes redesigned around the 1:24 ratio, where human time is allocated to judgment, not line-by-line inspection.

Reco.ai got the hard part right. They didn’t just generate fast. They built the trust infrastructure to prove the generation was trustworthy. The $400 in tokens was the easy expense. The week of systematic verification was the investment that made the $500K savings real.

The question for every engineering leader is simple: you have the generation capacity. Do you have the verification infrastructure, and the measurement to prove it, to match?

---

Sources

• Reco.ai. “We Rewrote JSONata with AI in a Day, Saved $500K/Year.” March 2026.
• Will Larson. “Judgment and creativity are all you need.” March 2026.
• Stack Overflow. “Building shared coding guidelines for AI (and people too).” March 2026.
• Sonar. “Sonar Data Reveals Critical Verification Gap in AI Coding.” January 2026.
• Faros AI. “The AI Productivity Paradox Research Report.” 2026.

Curious whether the AI on your team is closing the gap between generating fast and shipping with confidence? Discover how to measure AI impact.