What does Dr. Jonah Tebaa on When One AI Prompt Isn't Enough mean in practice?
According to Dr. Jonah Tebaa, one AI prompt is not enough when a task risks silent errors and features verifiable internal logic. Rather than relying on a single pass, complex processes like invoice extraction benefit from a three-step pipeline involving document classification, targeted extraction, and arithmetic validation to catch plausible mistakes. Tebaa decides whether to add workflow steps by applying a five-question framework that tests for self-checks, silence risks, volume-adjusted costs, latency budgets, and escalation costs.
Picture roughly 300 supplier invoices landing on a distributor's desk in a single week — some in Arabic, some in English, some clean PDFs, some phone-camera scans of a stapled stack. Someone has to decide how an AI system reads them: one well-crafted prompt to a vision-capable model, or three separate steps that check each other's work before a human ever sees the output. Dr. Jonah Tebaa has spent a fair amount of his applied-AI practice arguing that this decision, not the choice of model, is where the real skill in building with AI agents lives.
The Question Underneath the Model Choice
Most conversations about AI implementation focus on capability — which model is smartest, which vendor has the best benchmark. Tebaa's framing skips past that argument entirely. In his account, a single prompt and a three-step pipeline can use the exact same underlying model and produce meaningfully different error rates, because the difference isn't intelligence — it's structure. A single call has to be right the first time. A decomposed process can check itself before it hands anything to a human.
For the invoice-processing task — extracting line items, quantities, unit prices, and VAT to reconcile against purchase orders — the one-prompt version does all of that in a single pass. The three-step version splits the work: classify the document type, extract with a prompt routed to that type, then run an arithmetic pass that checks whether the extracted line items and VAT actually sum to the stated total. That third step is the one Tebaa treats as the interesting part, because it isn't extracting anything new — it's catching what the first pass got wrong.
Tebaa's structural point is not an idiosyncratic one. Google's own Vertex AI prompting guidance tells builders to break down complex tasks into simpler prompts, and its stated reason is that "Smaller prompts can help you improve controllability, debugging, and accuracy." Those are the three properties the arithmetic-check step is buying. What Tebaa adds is the part the vendor documentation leaves out — when that extra controllability is worth paying for, and when it is only extra cost.
An Illustrative Comparison, Not a Case Study
To make the trade-off concrete, Tebaa walks through a comparison built on round, illustrative figures — his own words for it — rather than an audited result from a named client engagement. On a 40-invoice sample of the kind this task typically involves, the single-prompt approach flags six documents as low-confidence. A hand audit of the full batch finds eleven real extraction errors, meaning five wrong extractions passed through as clean, because a single answer has no independent way to catch its own arithmetic inconsistency. The three-step version's validation pass catches nine of those eleven errors, since a wrong extraction usually breaks the internal math even when the line item itself still reads as plausible.
The cost difference in his illustration is modest in absolute terms — roughly $0.02 per document for the single prompt versus roughly $0.06 for the three-step version, or about $6 versus $18 a week at that volume. The number Tebaa keeps returning to isn't the twelve dollars. It's the judgment call sitting on top of it: whether twelve dollars a week is worth catching nine of eleven silent errors on documents that feed directly into a company's payables. That judgment, in his framing, is the actual craft — not the model selection that usually gets the attention.
Five Questions Before Adding a Step
Rather than treat decomposition as a default best practice, Tebaa argues it should pass a specific test before it's added to any workflow. He organizes the decision around five checks:
- The self-check test — does the task carry an internal consistency that can be verified as a separate step, such as numbers that should sum, dates that should sequence, or references that should exist? If so, decomposition is close to free value, because the system isn't being asked to grade its own homework.
- The silence test — does the task fail loudly, in a way that's obviously wrong and gets caught, or silently, in a way that looks plausible and isn't? Silent-failure tasks need a validation step; loud-failure tasks usually don't.
- The volume-adjusted cost test — multiply the per-call cost difference by real volume before dismissing the more expensive path as not worth it.
- The latency budget test — does the answer need to come back synchronously, or can the job batch overnight? Extra steps only cost time a process doesn't have when the output is needed immediately.
- The escalation-cost test — build the validation step so it routes to a human only when the check fails, not on every run. Decomposition should reduce the review burden, not create a second job to manage.
Read together, the five tests function less like a checklist and more like a filter against a default instinct — the instinct to either automate everything in one pass for speed, or add layers of review out of caution without asking what each layer actually buys.
Where This Cuts Against Common Practice
The instinct in most AI rollouts runs in one of two directions: ship the fastest, cheapest single-call version and hope the error rate is tolerable, or bolt on review steps everywhere out of general caution, regardless of whether a given task actually fails silently. Tebaa's framework rejects both defaults. It asks a builder to name, in advance, whether a specific task can fail without anyone noticing — and only pays for a second step where that answer is yes.
That distinction matters most for anyone deploying AI against financial, medical, or legal documents, where a plausible-looking wrong answer is far more costly than an answer that visibly breaks. For lower-stakes tasks — where an error is either obvious or inconsequential — his argument implies the opposite conclusion: added steps are often just added cost. The five-question framework doesn't tell a team to decompose more or less. It tells them to ask, task by task, whether the extra step is buying something real.
