Every meaningful step is first written down along with the reason it was chosen, then independently checked — before it turns into code, a build, or a promise to a client. Below are concrete cases: what the situation was, what was done, and what came out of it.
How the pieces of this approach connect — from a task to a result.
flowchart TD
TZ["Task
(original wording — not edited;
a new version = a new file)"] --> Q["Question
(what's unclear and what the answer changes)"]
Q -->|investigates| S["Findings
(answer to the question)"]
Q -->|resolves| D["Decision
(proposed →
accepted only by a human)"]
Q -->|tests in practice| E["Experiment
(success/failure criterion
set BEFORE, not after)"]
S -.->|"fact useful
beyond this task"| K["Knowledge
(one topic — one file)"]
D -.->|"fact useful
beyond this task"| K
E -.->|"fact useful
beyond this task"| K
S -->|"external source"| IST["Source
(original — not edited)"]
S --> D
E --> D
D -->|"final text/code"| ART["Result
(what was produced, announced in advance)"]
CRIT(["independent review"]) -.->|"required before handoff"| TZ
CRIT -.->|"required before handoff"| D
The fastest and most common cases — minutes between the moment an error appears and the moment it's found and fixed, before a human ever sees the decision.
The decision text explicitly stated that no unverified model name would make it into the final evaluation. In practice, one cell of the options table contained a specific name that no one had checked.
Time between the decision landing on the table and the mismatch being found and closed: 15 min.
The first count of undocumented projects turned out to be wrong. While fixing it, a different, new error crept in — in the exact spot that had just been corrected.
Sometimes the check catches not arithmetic but substance: a claim that was never actually in the source.
Of three quotes presented as verbatim, one turned out to be entirely invented: it mentioned Russia, yet the word "Russia" never appeared on the source page — confirmed by a direct full-text search. Two more turned out to be paraphrases presented as quotes, with no quotation marks in the original.
An automated build targeting several platforms at once is its own source of surprises, resolved by repeating the same cycle: try, find the cause, fix.
Three passes in one day — and the build has stayed stable across all platforms ever since.
The longest and most eventful path — board games bundled into a single mobile app. From the first folder created to a publicly downloadable build, the same cycle played out: a decision written down, an independent check, a fix, the result recorded — just repeated many times over on the same task as it grew.
The Android build is published and downloadable via a direct link. Before considering it ready, the build file was unpacked by hand to confirm the exact fix the build existed for (correct handling of on-screen touches) was actually inside — not just trusting the green check, but looking at the contents. Each of the five games was run live before publication, in both color themes, through every input method — touch, mouse wheel, right-click, keyboard shortcuts, two-finger gestures.
A multi-stage automated build once stalled on the last step, which looked like an infrastructure failure. On closer inspection, the cause wasn't infrastructure at all, but how the task itself had been worded at the previous step — recorded plainly as a wording error, not someone else's failure. Another time, a verification step took a previous step's own claim at face value ("no database connection") instead of checking it independently; a manual review found the real cause (a missing authorization header and a request to a model that didn't exist) — and that, too, was stated outright: "the claim was inaccurate and wasn't re-checked," with no softening.
Content generation for the game picked and switched the language model and prompt wording directly, bypassing the usual step-by-step breakdown — but even here, the model choice was recorded along with the reason, not made silently. When the very first real run caught an actual flaw in the prompt wording (fields had been swapped, and the translation rate came out at 1 of 17 instead of the expected roughly 7 of 11), the fix brought the result up to 14 of 16 — above the original target — and the difference was stated plainly in its own words: "the model translates more readily than expected," not written off as an error.
Three concrete improvements, each grown out of a real case, not general reasoning.
When a human steps back into work already in progress with a new instruction mid-stream, that instruction is now recorded in their own words at the moment it's given — not reconstructed afterward from whatever the outcome happened to be. For the same reason this matters to larger teams: in surveys of engineering and portfolio leaders, the ability to tell AI work apart from human work remains out of reach for more than half of teams without a mature practice around AI agents — and improves sharply for those who already have one.
A decision about a time limit for an AI opponent in one of the games was made unilaterally in conversation, skipping the usual check — it turned out to be incomplete and cost roughly an hour of wasted compute time. The same gap later turned up in three decisions about the workflow itself, which had been written and applied directly in conversation, bypassing the very check they described; once they were actually run through a proper review, all three needed rework, one of them with a flaw that would have made the mechanism unworkable for nearly everyone it was meant for. Now any description of a new workflow or set of instructions goes through review before it's put into use, not after.
During two parallel tasks, a whole set of real, technically confirmed small issues surfaced: one kind of CSS comment silently breaks the parser; a browser screenshot tool holds a minimum height regardless of the width requested; pixel-based measurement nearly got fooled by font anti-aliasing on some boilerplate text — caught only by a second, independent check done a different way. Almost all of these would have stayed buried inside notes for one specific task — now every confirmed finding gets its own short write-up, so the next task doesn't have to rediscover the same thing from scratch.
A pitch tested by restating it in plain words, and three channels where the right audience already is.
Dedicated online communities built around AI-agent development range from hundreds of thousands to over a million members — exactly the people working with these tools daily, not a random venue.
Juried industry conferences that bring together founders and engineering leaders already adopting agents — a more expensive channel to enter, but one that reaches decision-makers directly.
The existing network of consultancies and integrators around the Claude platform — an already-vetted pool of firms with clients ready to pay for AI-agent adoption, with no need to build an audience from zero.
For a partner who simply refers a client — 10-15% of the first contract's value as a one-time payment. For a partner who implements or provides ongoing support themselves — 20-25% of the support fee, for as long as it continues. The range is built on industry benchmarks for consulting and SaaS partner programs, discounted for the fact that ongoing support is live human work, not a product with zero marginal cost to serve.