This is from the private community and it will help guys tremendously in app development, free. I hope those in here will appreciate this later.
Okay, this is a big one.
I just posted the new workflow kit. It’s called the Agentic Workflow, and it replaces both versions I’ve shared before: the original six-file kit, and the tier-based one that came after it. If you’re mid-project on one of those, nothing breaks; finish what you’re on. But everything new should start here, and I want to walk you through why, because the jump this time is bigger than the last one.
The short version: I stopped being the safety net, and I stopped treating a half-built app like a bank vault. Let me explain both, because they’re the whole point.
**The thing that actually changed my mind.**
Every version of this workflow has had the same blind spot, and I didn’t see it clearly until recently. When one AI builds something and then checks its own work, it grades itself easy. Not because it’s lying to you. It’s because it’ll quietly take the cheapest path to calling something “done.” It’ll test a fake version of the screen instead of the real one. It’ll tell you a sweep is “covered” without ever actually running it. It’ll hand you a green checkmark that was never executed. I’ve watched every one of these happen on real code.
You cannot audit your way out of that with a better prompt. I tried. The old kits had me reading every prompt twice hunting for weak words, then reading every diff by hand before I’d let anything ship. It helped. It also made me, personally, the entire safety system. By hand. Forever.
The fix in the new kit is structural, and it’s the whole game: **no engine grades its own homework.** There are two engines now instead of one. Claude Code builds the thing, and Codex (a different model, that didn’t write a single line of it) comes in and tries to break it, driving the actual running app, against a standard we set *before* the build even started. The only thing that passes is what both of them agree is clean. That one change catches more than any amount of me squinting at diffs ever did, and it gets *better* as the models get smarter, not obsolete.
And before anyone counts themselves out: two engines is the *strongest* version, not a requirement. If you’re running one engine and a second subscription isn’t in the budget right now, you still get the core of this. The reviewer just becomes a fresh, separate session instead of a second model. Same principle: the thing that checks the work is not the thing that wrote it. You lose a little of the edge that comes from two genuinely different models disagreeing, but you keep the part that matters. Start with what you’ve got; add the second engine later if and when it makes sense.
**The second shift: right-sizing the whole thing.**
The tier kit was heavy. Merge tiers, do-not-merge splits, layered re-verification, a whole panel of review bots. And honestly? Most of that is what you want once you have real users and real money on the line, where a mistake hits a paying customer. But *before* you ship, all that ceremony just slows the agents down for nothing.
So the new kit sizes itself to where you actually are. While you’re still building, exactly one brake stays on. I call it the floor, and it only stops the stuff you genuinely can’t undo: a secret about to leak into your git history, something irreversibly destructive, or a quiet change to one of the handful of facts your whole app is built on. That’s it. Everything else, the agents just fix: no asking, no “I’ll get to it later,” no stopping to check in with you. Get it to green, fix everything green needs, write down what changed. The branch is a sealed box and the floor keeps it sealed, so the agent doesn’t need a leash.
And to be clear, because someone always asks: this is not *less* safe. The part that catches the truly unrecoverable stuff is always on. The heavy ceremony from the tier kit isn’t gone. It comes *back* automatically the day your app has real users. You just don’t pay for the vault while you’re still pouring the foundation.
**The install is the part I’m actually proud of.**
This is where you’ll feel the difference in the first five minutes.
The first kit didn’t install anything. It handed you docs and made *you* the safety system. The tier kit was better, but it made you *build* the safety machinery yourself, firing off a backlog of prompts one at a time to construct the guards and the scanners, and then work through a checklist to confirm you’d wired it all up right.
The new kit is one command.
You run it, it wires the safety rails into your repo and sets everything up, and then it does the thing I think every tool should do and almost none of them bother to: **it plants a fake secret in your own project and makes you watch the rails block it.** You don’t take my word that the protection is on. You see it catch something, live, before you trust it with anything real. If it ever *didn’t* catch it, you’d find out on day one, not on the day it actually mattered.
That was the entire goal of the install: make “is this thing actually protecting me?” a question you answer by watching, not by faith.
**What’s gone, for the folks who’ll notice.**
If you’re coming from the older kits: the six-file memory system, the giant prompts with iteration caps and parallelize lines, the read-every-prompt-twice-for-hedge-words audit, pasting patches one at a time to approve them. All of it retired. Not because they were wrong. They were the rungs that got us here. But telling the engine *what* you want and letting it own the *how* beats micromanaging it, and a second engine plus a hard floor beats me hand-checking everything. It came out simpler *and* safer at the same time. That basically never happens, and it’s the reason I made the switch.
**To get started:** grab the kit, drop it in your project, run the one command, and then, seriously, go plant a secret or break a rule on purpose and watch it get stopped. Once you’ve seen the floor actually work, you’ll trust it, and then you just build. Everything you need to understand it lives in two files: a short doctrine that’s the whole philosophy, and one guide that walks through every piece.
That’s it. This is the one I’d hand a friend. Go run it.