Skip to content
Period 8 / 12

Practice 03: Demand Evidence, Not Assurances

"Done" is a claim, not proof

An agent reporting "done, all invoices processed" is a claim, not proof. And the fix isn't to ask "are you sure?" Models grade their own work generously, the same way nobody writes a harsh review of their own report. Taken at face value, the assurance can hide real mistakes: twelve mismatches surfacing three weeks later isn't really a twelve-row problem, it's a trust problem. Everything now has to be re-checked, forever, which erodes the entire productivity gain the tool was supposed to provide.

The fix is to build the check into the task itself, not to bolt it on afterward.

Demo: two spreadsheets that don't match

A CRM export and an accounting export of the same data, reconciled by hand, is one of the oldest sources of quiet dread in a finance or ops role. As the first worked example, here's what happens when that exact task is handed to Claude Code, and everything needed to run a comparable version yourself, not just read about it.

Build the two files yourself

Two CSV exports in a folder, seeded with realistic mismatches: a few missing invoices, a couple of amount differences, a near-duplicate that isn't quite what it first looks like, and a currency inconsistency the two systems disagree about. Save the two blocks below as crm_export.csv and accounting_export.csv in the same folder to reproduce something comparable:

Files changed
crm_export.csv
accounting_export.csv
csv
# crm_export.csv
invoice_id,customer,region,amount,currency,date
INV-1001,Nordwind GmbH,North,4200.00,EUR,2026-06-03
INV-1002,Alpen Logistik,South,1875.50,EUR,2026-06-04
INV-1003,Bergmann AG,East,930.00,EUR,2026-06-05
INV-1004,Nordwind GmbH,North,2650.00,EUR,2026-06-07
INV-1005,Seestern Handel,West,1120.00,USD,2026-06-09
INV-1006,Bergmann AG,East,930.00,EUR,2026-06-05
csv
# accounting_export.csv
invoice_id,customer,region,amount,currency,date
INV-1001,Nordwind GmbH,North,4200.00,EUR,2026-06-03
INV-1002,Alpen Logistik,South,1950.50,EUR,2026-06-04
INV-1004,Nordwind GmbH,North,2650.00,EUR,2026-06-07
INV-1005,Seestern Handel,West,1120.00,EUR,2026-06-09
INV-1006,Bergmann AG,East,930.00,EUR,2026-06-05

Four seeded mismatches, on purpose: INV-1002's amount disagrees (1875.50 vs 1950.50), INV-1003 is missing entirely from the accounting export, INV-1005's currency disagrees (USD vs EUR: the same amount, different currency, which is not actually a match), and INV-1003/INV-1006 share identical customer, region, amount, and date (Bergmann AG, East, 930.00, 2026-06-05) under two different invoice IDs. Is that the same invoice billed twice under different numbers, or two separate charges that happen to match? Nothing in either file answers that on its own, which is the point: it's a judgment call that needs a source document, not a spreadsheet, to settle.

The literal prompt

With both files saved in that folder, open a terminal there, run claude, and type this exactly:

Put yourself in Plan Mode. I have two CSV exports in this folder, crm_export.csv and accounting_export.csv, covering the same invoices from two different systems. Reconcile them: match records on invoice_id, flag any amount or currency mismatches, flag anything present in one file but not the other, and flag duplicates. Give me a matched tab, an exceptions tab, and a written summary of what didn't reconcile and why.

Put in Plan Mode, the agent reads both files and reports back what it intends to do before doing anything: match records on invoice ID, then run four specific checks. On the sample data above, it proposes dropping the region column from the exceptions tab because most rows share the same value. Nothing has been touched yet, and that's practice 01 at work: it's the moment where a correction is nearly free. In this run, the correction is small: "also break down variances by region, and keep the region column," a single sentence, added before a single row changes.

Once approved, the agent works through the reconciliation: matching invoices, flagging the ones that don't line up, and writing an exception summary. On the sample data above, a comparable run reports: INV-1002 flagged for an amount mismatch (1875.50 vs 1950.50), INV-1003 flagged as missing from the accounting export, INV-1005 flagged for a currency mismatch, and INV-1003/INV-1006 flagged as a possible duplicate billing under two invoice numbers, surfaced as a question for a human to resolve, not a fact the agent asserts on its own. What it hands back isn't just a cleaned file: it's a matched tab, an exceptions tab (including that possible-duplicate flag), and a written summary of what didn't reconcile and why. Reading two of those exceptions out loud, including the invoice pair the agent couldn't resolve on its own, is the difference between trusting the output and having to re-derive it.

This is deliberately small enough to run in one sitting

Six rows a side is small on purpose: enough to seed four distinct mismatch types without requiring a real dataset. The same prompt, pointed at fifty rows or five hundred, does the same job; the reconciliation logic doesn't care about row count, only about whether the check was actually built into the ask.

Make evidence part of the deliverable

Instead of "process these contracts," the brief becomes "process these contracts, and give me a table with a source citation for every value, plus a list of anything you couldn't resolve." Two things follow from that one addition.

What changes when evidence is requested up front

First, the agent catches its own misses: asking for an exception list forces it to actually look for exceptions rather than paper over them. Second, review collapses from re-doing the entire task to spot-checking a handful of citations, which takes minutes rather than hours.

Reconciliation view

Totals lined up side by side, so any gap between what should match and what actually does is obvious at a glance, not buried in two hundred separate rows.

Exception list

Everything the agent couldn't resolve, named explicitly. Asking for this list is what forces the agent to go hunting for its own misses instead of quietly smoothing over them.

Control total

One number, checkable in seconds, that stands in for the whole reconciliation: the fast path to "this is right" without re-reading everything underneath it.

Source citation per row

Every value traces back to the exact page or row it came from, so a spot-check takes minutes instead of an afternoon.

That shape repeats across almost any task an agent is handed (reconciliation, contract review, report generation) because the same four questions apply: what matches, what doesn't, how confident is the summary number, and where does each value actually come from.

Demo: a contract folder becomes a renewals tracker

The second worked example: roughly thirty vendor contracts as PDFs, turned into one tracker (renewal date, notice period, auto-renewal flag, risk flag) with a source-page citation on every row.

The brief explicitly requires the tracker, a citation per value, a confidence note, and an exceptions list. Plan Mode runs first, same as demo one; the plan gets approved quickly this time, because the planning discipline from practice 01 is already established.

The moment worth remembering is what happens in the exceptions list, not the tracker itself: the agent reports two contracts it could not confidently read (one with a contradictory amendment, one a bad scan) instead of guessing at an answer and presenting it with false confidence. That sentence is worth more than the whole tracker, because it's the difference between an agent that hides its own uncertainty and one that surfaces it. Spot-checking a single citation, opening the source PDF at the cited page and confirming the renewal clause, takes about two minutes and beats two hours of re-reading the whole folder by hand.

The checker is never the doer

There's a sharper version of this practice worth adopting even with zero setup: open a fresh session with no memory of the work, and instruct it to check the file against the sources, assuming it's wrong until proven otherwise.

Why a fresh session checks better

A session grading its own output has every incentive, structurally, to see it as fine. A fresh session has no such incentive: it starts from "assume it's wrong" and has to be convinced. This manual version of adversarial checking is worth doing today; the fully automated version of it (a dedicated second agent whose only job is to verify) is covered later in this course, once the other practices are in place.

Quick check — An agent reports a task is 'done.' What actually resolves whether that's true?

The rule of thumb: no one would accept "trust me" from a new hire on month-end numbers. The same standard applies here: evidence is part of the deliverable, not an optional extra.

Continue to Lesson 08

Practice 04: turning one-off corrections into a standing handbook so they never have to be repeated.

Have a question about this lesson?

Reply here and it goes straight to Rod. Same as replying to one of his emails.