You Don't Need to Read the Code

# You Don't Need to Read the Code *How non-technical founders can assess their own AI judgment — and their agents'.* --- I run NUVC — an AI-native VC intelligence platform — on 24 agentic teams and zero employees. People assume the hard part was building the agents. It wasn't. The agents were the easy part. The hard part is that every one of them hands me work that looks finished, and I am the only thing standing between "looks finished" and "is correct." That's the job now. Most founders I talk to haven't noticed it changed. ## The uncomfortable research finding Google's DORA team studied nearly 5,000 technology professionals in 2025 and reached a conclusion that should worry anyone building with it: **AI is an amplifier.** Strong teams got stronger. Weak teams got their existing dysfunction magnified, faster. The tool didn't lift anyone up a level. It multiplied whatever was already there. That was a study of software teams. I'm applying it to how you run a company, and I think it travels — but you should know I'm making the leap. Which means the question "should I use AI more?" is the wrong one. The right one is "what am I amplifying?" Then there's the finding that actually changed how I work. Anthropic's AI Fluency Index read almost 10,000 real conversations to see how people behave when AI hands them something polished, and found that we become **more directive and less evaluative**. When the output looks finished, people specify the format more — up 14.5 percentage points — and check the facts *less*, down 3.7. They question the reasoning less. They spot missing context less. Read that again, because it's the whole problem. The better the output looks, the less we examine it. Polish is not evidence. Polish is a sedative. I lost roughly AU$1M as an angel investor making decisions by gut and network access. I didn't write an essay about investing better — I rebuilt the decision process as a system. So I have some sympathy for the instinct to trust a confident-looking answer. It's the same instinct that lost me the money. ## The ladder — where are you actually? I built this rubric to hire engineers. It turned out to apply to everyone who directs AI, including me. Five tiers. Find yourself honestly. **L1 — you accept output and ship it.** It looked right. You didn't check. **L2 — you chat with it.** Back and forth, conversational, and you ship when it feels done. "Something will catch it if it's wrong." **L3 — you ground it.** Before you trust the output, you check it against the actual source of truth — the real number in the dashboard, the actual contract, the primary document. You catch confident-and-wrong *before* it ships. **L4 — you orchestrate.** You run multi-step work, verify against external contracts, and you've built at least one reusable check. **L5 — you build the guard rail.** You create the check that stops a whole class of error from ever happening again — for everyone, not just you. **L3 is the floor.** Not the goal — the floor. Below it, you should not be directing AI on anything consequential, and that applies to the founder as much as the intern. I hold myself to it. I've dropped below it and had to climb back. Most people reading this are at L2 and believe they're at L4. The tell is simple: **can you name the last time AI gave you something confidently wrong and you caught it?** If nothing comes to mind, you're not catching them. They're getting through. ## The four dimensions — and the two that matter Underneath the ladder sit four capabilities. Anthropic's framework calls them the four D's, and the split between them is the most useful thing here. **Delegation** — knowing what to hand over and, more importantly, what not to. Can you name three things you refuse to let AI decide? **Description** — the quality of your brief. Do you load the real context before asking, or do you open with a vague sentence and iterate your way toward the point? **Discernment** — catching confident-but-wrong. Checking against the source, not against your impression. **Diligence** — producing the artefact that *proves* it. A test, a cross-check, a cited primary source. Something that would fail loudly if the work were wrong. Here's the asymmetry that matters. Delegation and Description buy you **speed**. Discernment and Diligence buy you **correctness**. Almost everyone invests in the first two, because the payoff is immediate and visible. The second two are where the losses live, and their payoff is invisible — it's the disaster that didn't happen. Speed with no discernment isn't productivity. It's just being wrong at scale. ## What this looks like when you can't read the code Non-technical founders tell me they can't evaluate AI output because they don't understand the technical detail. That's the wrong frame, and it lets you off a hook you shouldn't be let off. You don't need to read the code. You need to check the claim against reality — and you can do that in any domain you actually run. The output quotes a customer number. Open the dashboard. Count. It cites a source. Open the source. Does it say that? It quotes a price. Check the price list. Is that price still live? It names a person, a clause, a date. Verify one of them. None of that requires technical skill. It requires the discipline to do it *when the answer looks right* — which is precisely when nobody does it. In a recent audit of my own system, I found agent instructions quoting a price for a product that had been free for months, a record count off by roughly a factor of four, and a citation to a document that did not exist. Every one of those looked completely plausible. That's the point. **Wrong things that look wrong are harmless. Wrong things that look right are the whole risk.** ## The trap inside the checking There's a failure mode hidden in all of that, and I walked into it this week. Checking isn't the same as checking against the right thing. One of my own agents told me a number about my own company was wrong. It had verified — counted the files, cited the internal documentation, shown its working. Thorough, confident, and wrong, because the internal docs don't govern that claim. I do. It had grounded against *a* source instead of *the* source, and from the inside those two feel identical. So there's a rung hidden inside L3. Before you check, decide who owns the answer. A number about your company is governed by you, not your wiki. A price is governed by the price list, not the deck quoting it. A customer count is governed by the database, not last quarter's board pack. Grounding against a plausible source isn't discernment. It's L2 wearing L3's clothes — and it will pass every self-assessment you ever give it, because the work *felt* like diligence. ## Now assess your agents with the same shape The framework runs in both directions. A human earns an **authority** tier. An agent earns an **autonomy** tier. Same rubric, same evidence bar. For each agent, tool, or automation you've set up, answer three questions. **What does it actually know?** Not what it can theoretically do — what specific, current context is loaded into it. An agent with a generic brief will produce generically wrong work with total confidence. The value isn't the model. It's the context you gave it. **What can it break?** Sort every action into reversible, bounded, or irreversible. Reversible, let it run. Bounded, let it run and review a sample. Irreversible — money moving, data deleted, anything a customer sees, anything you can't take back — that stays blocked until a human says yes. If you haven't drawn that line explicitly, you've drawn it by accident. **How would you know if it failed?** This is the one nobody has an answer to. If your automation silently stopped working tonight, when would you find out? If the honest answer is "when a customer complains," it isn't automation. It's an unmonitored liability. I found three of my own scheduled jobs that had been failing every single night for weeks. Nothing alerted. They just quietly did nothing, and the system reported no problem, because nothing was watching. An agent with capability and no owner is not an employee. It's an orphan with your credentials. ## The two habits Everything above collapses into two practices, and they're free. **Never accept the first output on anything that matters.** Iteration is the strongest predictor of every other good behaviour in the Anthropic data — people who go back and forth question the model's reasoning **5.6 times** more often, and catch missing context four times more often. The first draft is a starting point, not a deliverable. **Distrust polish.** A finished-looking artefact is the *trigger* to ask "is this accurate, what's missing, does the reasoning hold" — not the signal to ship. ## The test Here's the assessment, and it takes ten minutes. Take the last significant thing AI produced for you. Find one factual claim in it — a number, a name, a date, a citation. Go to the actual source and check it. If it's right, you've lost ten minutes and gained some evidence about your system. If it's wrong, you've just learned that everything else you shipped this month had the same odds — and nobody checked those either. The founders who'll do well with this technology aren't the ones who use it most. They're the ones who can tell when it's lying to them. That's a skill. You can measure it. Start today. --- *Sources, since that's rather the point: Google DORA, [State of AI-assisted Software Development 2025](https://dora.dev/dora-report-2025/) — nearly 5,000 technology professionals. Anthropic, [the AI Fluency Index](https://claude.com/resources/tutorials/a-discussion-guide-for-the-ai-fluency-index) — almost 10,000 conversations. Check them.*