---
title: "Verification is the name of the game"
description: "How AI changes the economics of software verification, and how teams can build confidence in generated code through layered checks and feedback."
url: "https://www.cxo.dev/blog/verification-is-the-name-of-the-game"
last_modified: "2026-11-13T18:21:02Z"
---

# Verification is the name of the game

> How AI changes the economics of software verification, and how teams can build confidence in generated code through layered checks and feedback.

[View this page on CXO.dev](https://www.cxo.dev/blog/verification-is-the-name-of-the-game)

Published 2026-11-13T09:00:00-08:00 · Claire Vo + Zach Davis

![A disassembled computer cooling fan, with its square frame and wire connector beside the detached fan blades.](https://assets.cxo.dev/newsletter/2026-11-13-fan-halftone-1200x400-email.png)

AI-generated code can’t be trusted. At least that’s what many of the haters, doubters, and skeptics would have you believe. And you know what? They’re not wrong. You shouldn’t blindly trust AI-generated code; you should verify it.

When humans type code character by character with their little meat fingers, they rarely produce working, mergeable code the first time around; they get there through iteration, reading nearby code to increase understanding, testing changes manually, and running automated checks for feedback. In fact, many of these checks were built directly into modern code editors to shorten feedback loops and speed up the path to working code.

LLMs continue to get better and better at generating code that could plausibly work, but without verification loops of their own, the skeptics are right: the code they produce can’t be trusted. So you can sit back and say “I told you so”, or you can get to work fixing your verification gaps.

There is no such thing as code you can’t trust; there is only code that hasn’t been sufficiently verified yet. Pre-AI software development lifecycles (or SDLCs) were by and large designed to balance verification with cost and practicality. Many forms of verification are costly to develop and maintain; others can be costly to run, in time or compute or both. How much verification was considered “worth it” depended on scale, domain, impact, and how quickly you could detect and recover from problems.

Most of this is still true in the age of AI, except that the time and effort to develop, maintain, and run verification loops can be mostly offloaded to AI (which still incurs a cost in the form of inference, but typically a smaller one compared to paying humans alone to do the same work). So feasibility has exploded, which brings us to our central question:

> If you don’t trust the code that’s being produced by LLMs, what layers of verification would you need to put in place to feel confident shipping it?

Start with fast, deterministic verification like linting, type checking, and formatting. If any of these are slow, find a faster option (there’s been a lot of improvement in tooling here since AI use has become widespread). Ideally these are fast enough to run after any edit (agents are pretty good at this these days, but you can set up hooks if you want to be sure).

Layer on automated, deterministic tests. Unit tests, functional tests, integration tests — whatever you need to feel confident. There’s been a lot of conversation recently about whether tests still add value. Our view is you can’t beat well-structured deterministic tests for cost and reliability. In theory you can have agents exhaustively check your app for every change, but that’s an expensive way to get baseline confidence about your change.

Quite possibly you already have all this, but you still wouldn’t ship AI code without careful review. So we go back to our question: what else do you need to feel confident?

Layer on adversarial agentic review so that things like logic bugs, code quality and consistency issues, and more get addressed before any human is asked to review a change. Add thorough automated security reviews. Have the agent run your app and prove that the change actually does what you asked for. Automatically assess and score impact, risk, and more. When a bug gets through, it’s not an existential failure; it’s a learning opportunity to improve the system and prevent the next one.

So, no, trust does not come for free. You must build that trust, both through actual technical investment in verification loops and feedback, and also in experience and exposure. The teams that put the most trust in AI are not the least risk-averse ones. They’re the ones that have made the investments, measured progress, and demonstrated that AI-generated code paired with robust layers of verification actually causes fewer production incidents than humans alone, not more.

Here’s what we’re reading this week:

---

### [Addressing the code review bottleneck](https://x.com/BHolmesDev/status/2118411592627052937)

Ben Holmes from Warp.dev on how to use verification to clear your team’s PR backlog. He lays out three main levers: adversarial review, “manual” agentic end-to-end verification, and automated risk scores.

> None of these remove the human bottleneck on code review; engineers should continue to stay involved in how a codebase evolves. All of these are meant to a) increase trust in the work an agent delivers, and b) reduce the human attention needed to get work to the finish line.

### [Verification before and after release](https://x.com/copyconstruct/status/2118529738532925725)

Cindy Sridharan says that 70% of her token use goes to verification now, and then [follows up](https://x.com/copyconstruct/status/2118539184654938154) with a comprehensive list of verification techniques, both before and after deploy.

### [Making coding agents trustworthy](https://x.com/TheTuringPost/status/2120607968408531110)

Takeaways from Lauren Tan’s talk at AI Engineer Code Summit this week ([the whole talk](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=3660s) is worth your time). Lauren also says that most of her token usage goes towards verification, and that the economics of verification have changed. She also recommends investing in the codebase and verification loops before going too far down the automation track.

> We’re entering a golden age of software testing and verification.

### [What makes a software factory](https://x.com/EnoReyes/status/2118767454721851680)

Factory CTO Eno Reyes with a thoughtful entry into one of this week’s hot discussion topics, what even is a software factory and do you need one. The people who are building software factory products unsurprisingly have very good language for talking about what a software factory is and what goes into a useful/successful one. Eno lays out the concept of “signals”, the inputs that trigger work, and also talks about something we didn’t really cover above but is tightly coupled to verification loops: feeding lessons from production failures back into your verification loop design and implementation to make future failures less likely.

### [State of the tech job market: late 2026](https://www.lennysnewsletter.com/p/state-of-the-tech-job-market-late)

Everyone’s favorite Lenny dropped his “late 2026” state of the tech job market report. Things that caught our eye:

- Claude is becoming a top design skill (#2 after Figma)

- Hiring for UX Research is down 66% from 2022. We think AI-pilled UX researchers are actually more valuable right now, but the market isn’t reflecting that.

- Verification is becoming a product skill. “Evals” is among the top ten PM skill terms.

### [Gemini Decisions API](https://x.com/sundarpichai/status/2120581155078729728)

Google released their decision model and Decisions API. Cheaper than OpenAI Decisions API, more expensive than Jev. Early results on benchmarks are very promising.

---

### One thing to try this week

Tired of wading through agent slop in your PR descriptions? Simon Willison suggests [hiding the agent content in a collapsed section](https://x.com/simonw/status/2119650353142747181). You’re welcome.

---

Trust the process.

*— Claire + Zach*

## Sitemap

- [Site index](https://www.cxo.dev/llms.txt)
- [Full sitemap](https://www.cxo.dev/sitemap.md)
- [Visiting agent guide](https://www.cxo.dev/AGENTS.md)
