Here's a confession that should probably scare you: most days, I approve work I can't read.
I'm not an engineer. I run an AI that writes code, builds lists, digs through public records — and before it does any of it, it shows me a plan and asks, basically, "good?" I say good. It goes.
That little "good?" is the most important moment in the whole thing. It's the contract. It's me signing.
And for a long time the plan I was signing looked like a parts catalog. A wall of file names, settings, and command lines. The engine bay, not the dashboard. I'd skim it, not really understand it, and say "good" anyway.
You've done this. We all do this. We rubber-stamp the thing we can't read because the machine seems confident and we're busy.
Rubber-stamping a plan you can't read is like signing a contract in a language you don't speak because the other side smiled. Most of the time it's fine. The one time it isn't, it costs you.
This month, it almost cost me about $700.
What is plan mode, and why does the plan matter more than the code?
Plan mode is the step where the AI shows you what it's about to do before it does it. For anyone who can't read code — most founders, most revenue leaders, most buyers — that plan is the whole surface you get to judge. Read the plan, catch the mistake. Can't read it, and you're trusting the machine on faith.
So the plan is the product you're actually approving. You'll never look at the code. The plan is where you either catch the problem or sign it.
Can you trust AI coding agents?
Not on faith. You can't trust the code if you can't read it, and most people can't. What you can trust is the plan the agent shows you first — but only when it's in plain English and its numbers add up. People are asking this out loud right now: "Can AI agents be trusted?" is a live question on Google as of June 2026 (DataForSEO). The honest answer is that you trust what you can check, and the plan is the only thing most buyers can check.
So I changed the plan. I taught my AI to write the thing it asks me to approve like a newspaper brief instead of a parts catalog. I call it Plain Plan Mode. Four things make it work:
Plain English, ninth-grade. Short sentences. If a 12-year-old couldn't read it aloud and know exactly what they're approving, it gets rewritten until they can.
A real "how," in plain words. It still has to tell me the method — which tools, wired together how — but it names a tool the way a newspaper would: "a web-research engine built for AI," not its insider code name. I approve the method, not a mystery.
Five little symbols, each meaning one thing. What you get. What it costs. A warning. A question for you. Your move. Your eye learns them in one read and routes itself.
An honesty rule on every number. This is the one that saved me.
What's the real risk of letting an AI build for you?
The dangerous mistake is the plausible one — a confident, clean, wrong number you approve because it looked right. You'd catch an obvious error. This kind wears a tidy headline and slides straight past you.
Here's the honesty rule in plain terms: if two numbers in the plan multiply into a third, they have to agree. Per-item price times the number of items has to equal the total. Sounds obvious. Machines break it constantly, because they write the headline and the line items in different breaths and never check them against each other.
While I was testing Plain Plan Mode, a sample plan headlined its cost as "$50 to $75." Cheap. Easy yes. But down in the same plan, the per-item price times the number of items came to about $700. Roughly ten times the headline. The AI had written both numbers itself — and never noticed they disagreed.
The rule caught it. The plan got bounced back and rewritten before it ever reached my "good?" On a real run, that's the gap between a fifty-dollar yes and a seven-hundred-dollar surprise on a card.
And these aren't toy jobs. Earlier this month I cleaned 1.34 million public franchise location records down to about 60,000 real multi-unit operators — the kind of list that's worth real money — where the final step is a small paid look-up on every single row. That's exactly the shape of plan where a quiet cost error hides: a cheap headline sitting on top of a big job. You'd approve it. I almost did.
How do you review AI work when you can't read code?
You stop trying to review the code and you make the plan reviewable instead. A plan you can read is a plan you can argue with. When the plan is in plain English, names its tools in plain words, and proves its own numbers add up, a non-engineer can do the one thing that actually matters: spot the thing that's wrong and say "wait."
That's the whole game. The AI got faster than any of us can check by hand. So you force it to show its work in a language you speak — and to prove its own math before it asks you to sign.
I built this for myself because I sign these contracts every day. Then I made it the default for everything I do, and shipped it. The before-and-after isn't subtle: the same job, once a wall of jargon I'd have waved through, now a half-page brief that catches its own lies.
The plan is the contract. Make the contract readable, and you stop signing things you can't see.
(If you want the deeper version of this idea — manufacture more information about a situation than the other side has, then hand it over plainly — it's the same instinct behind the Asymmetry Engine.)
Below is the geeky version. Copy it into Claude Code and rebuild the whole thing yourself.
Or don't. Annual subscribers install the plan style I actually built with one command — every tool I ship, all 3 courses, weekly office hours.
→ Go annual — $2,499/yr · Start at $50/mo (most readers start here)