Robert Echevarria The Dark Factory
May 21, 2026

The Standing Order

We were the bottleneck of our own AI. One pattern fixed it.

I build complex projects with an AI co-builder. We go down rabbit holes. I lose track of what's done. So does the AI. So we built one prompt that audits every previous phase, confirms where we are in the system, builds the next phase, and loops until the project ships.

Less timeThe dispatch ritual moves out of your head.
Fewer tokensContext stops getting reconstructed every session.
Less driftState becomes visible before new work starts.
Better qualityThe audit fires even when the human is tired.

A standing order turns fragile memory into operating infrastructure.

The loop is simple: audit the state, confirm the evidence, build one bounded phase, and leave a receipt the next session can trust.

01 - The problem

Both of us were getting lost.

The clearest failure happened in the middle of a build with too many moving parts: a phase map, intake logic, copy blocks, QA criteria, handoff notes, and a growing list of small decisions that all depended on each other.

We were three phases in. One part looked finished. Another part was half-finished. A third part had passed in the previous session, but only because neither of us noticed that the acceptance criteria had changed two steps later. The AI returned output that built confidently on top of something broken from two phases ago. I opened the session and could not tell what state the project was in. The AI opened the session and could not tell either. The prior session had ended. The thread had moved on. The state was now implied, scattered, and fragile.

The problem was not intelligence. The problem was state.

Fig. 01 - Session state splitState drift before the audit
AUDIT INSTALLED Reality What I thought What AI thought

Fig. 01 — Before the audit, we each thought a different project was being built. The gap was tokens, hours, and trust.

Across sessions, across phases, across days, neither of us could reliably answer the questions that mattered: what is done, what is half-done, what is already broken, and what is safe to build on top of?

Multiply that across several complex projects and the rabbit holes compound. The AI builds on a broken foundation. I miss the broken foundation because I am tired and the work looks like progress. By the time we notice, we have burned tokens, hours, and trust on output that has to be ripped out.

This was not a prompt problem. This was a coordination problem between two collaborators who had no shared, persistent memory of where the work actually stood.

We needed something neither of us could supply alone: a standing checkpoint that lived above both of us.

02 - The breakthrough

How we built the loop.

I got tired of opening every session by re-litigating the same uncertainty. I asked the AI why we kept losing the plot at the exact moment the work was supposed to accelerate.

The useful answer came back as a counter-question: what if the prompt that opens every session is the same prompt, and it does not try to build anything until it has first audited the project state?

That changed the design.

01
Audit
Before doing any new work, the prompt walks the prior phase outputs, checks them against that phase's done criteria, and flags anything incomplete, broken, or skipped. No new code. No new copy. No new build until the audit passes.
02
Confirm state
The prompt writes a short statement of where the project is: what has been verified, what the next uncompleted phase is, and what is gating it. This statement becomes the receipt. I can read it quickly. The AI can work from it directly. Neither of us has to pretend the chat history is a reliable operating record.
03
Build the next phase
Only now does work begin. The scope is exactly one phase. The done criteria are already known. The output is judged against the same standard that will be audited next time.
04
Loop
When the phase ships, the pointer advances. The next session opens, reads the same standing prompt, and starts with the audit again. The loop keeps running until there is no next phase to advance to.
Fig. 02 - The audit loopThe loop that runs first
STANDING PROMPT AUDIT prove state BUILD bounded scope RECEIPT leave trace YOU EDIT THE RULE The rule carries the next session.

Fig. 02 — The standing prompt opens every session. The audit runs first. The loop only advances when the previous phase passes.

That is the whole pattern. Four steps, written once, applied to every project. No clever wording. No magic. The intelligence is in the insistence on the audit before the build.

I wrote a single note in the project log the first morning the loop ran a project to completion on its own: "Should this become standard for all projects?"

It did.

03 - First-order consequence

Time and tokens.

Two things collapsed at once.

Time collapsed because I stopped being the dispatcher. The morning ritual disappeared: what is the state of project A, project B, project C; what is gated on what; what verification still has to happen; what can safely move today. The standing prompt did that in the first thirty seconds of every session and wrote the receipt I needed to glance at.

Fig. 03 - Same hour, different allocationDispatch collapses into work
Before
Dispatch Clarify Work Receipt
After
Audit Check Work Receipt
Dispatch or audit
Clarifying old state
Actual output
Receipt and handoff

Fig. 03 — Illustrative time allocation. Same total hour. The work-segment expanded into the space the dispatch ritual used to fill.

Tokens collapsed because the AI stopped re-litigating context. When a session opens with a clean audit and a written state, the AI does not have to reconstruct the project from chat history. It does not have to ask me clarifying questions I already answered four times. It moves straight to the next bounded scope of work.

The work that used to take three exploratory sessions to finish a phase now takes one focused session. The tokens that used to be spent re-establishing context get spent on actual output. Both savings are real. Both compound across multiple projects.

04 - Second-order consequence

The quality went up.

The quality improvement surprised me.

When I was the dispatcher, I skipped the audit half the time. I would open a session, glance at the prior output, decide it looked good, and tell the AI to keep building. Sometimes I was right. Sometimes the prior output had a subtle flaw: a broken assumption, a missing field, a verification we forgot to run, a handoff note that contradicted the phase map.

Fig. 04 - Audit frequencyThe audit stops being optional
50% Human attention catches what it can. The missed half becomes the risk surface.
0% Once the loop runs, audit cannot be skipped. It always fires first.

Fig. 04 — Illustrative audit-frequency shift. The standing prompt does not get tired. It walks the checklist every single time.

I missed those because I was tired, rushed, or already mentally on to the next thing.

The standing prompt does not skip the audit. It does not get tired. It does not decide the prior phase looks fine because it wants momentum. It walks the checklist every single time and refuses to build the next phase until the audit passes.

That changed the shape of the work. The output became cleaner not because the AI became smarter. Same model. Same collaborator. Same raw capability. The difference was that the process now had a mechanical floor underneath it.

Every phase had to prove it deserved to become the foundation for the next phase. That one constraint caught more issues than my attention could reliably catch by itself.

The loop did not just save time. It raised the floor.

05 - Third-order consequence

The standing order becomes the asset.

The standing prompt is not ephemeral. It is a file, in a repo, versioned, with a clear history of edits. Which means it is, suddenly, an asset of the business.

Fig. 05 - Compounding branchesThe standard compounds
STANDING ORDER IMPROVE fix once, inherit often AUDIT make judgment visible TRANSFER run without you All three compound when the standard lives outside the owner.

Fig. 05 — Three compounding properties. The first-order win is motion. The third-order win is sovereignty.

It can be improved. When we find a failure mode, such as an edge case the prompt did not account for, we do not fix the symptom in one session. We update the standing order, and every future execution inherits the fix. The system learns by editing the rule, not by repeating the lesson.

It can be audited. Someone new can read it and understand exactly how the work is run. Future me can see why a handoff requires a screenshot, why QA must include a failed-state check, why a phase cannot close without a log entry. The intelligence stops being trapped in my head.

It can be transferred. The same standing order can run on five projects in parallel. It can be cloned and adapted for a new domain. When the day comes that the business runs without me in the room, the standing orders are what make that possible. The business becomes legible to itself.

The first-order consequence is motion. The third-order consequence is sovereignty.

06 - Translation

What this means if you run a service business.

I am writing this for the operator who already knows AI matters and is still trying to figure out where to apply attention.

Every service business runs on recurring classes of work: onboarding a new customer, quoting a job, following up after an estimate, replying to a review, sending the post-service survey, closing the loop after the work is done. Each one has a standard. That standard usually lives inside the owner.

The leverage move is not faster emails or a smarter chatbot. It is writing the standing instruction once, using the audit-then-build-then-loop pattern, and letting the system carry the standard at 7am, at 11pm, on Christmas Eve.

You stop being the explainer-of-record. You become the editor of the standing order.

This is what separates automation from an operating system. Automation handles a task. A standing order carries the judgment around the task: what good looks like, what evidence matters, where the handoff goes, when to escalate, when to stop, and when to refuse to proceed.

Most owners are still using AI to do their work faster. The owners pulling ahead are using it to carry their work.

07 - If you are the bottleneck

The fix is a pattern you can own.

If you run an owner-led service business doing $3M to $15M in annual revenue, and you are sick of being the connective tissue between fragmented tools and fragmented advice, that bottleneck is the bridge.

Buildwise Media installs the operating system that runs the business outside the owner's head, on the owner's domain, with the owner keeping the asset.

The work is not handing you more software to manage. The work is extracting the standards already inside the business, turning them into standing orders, and making the operation legible enough to run without constant owner translation.

The bottleneck wasn't the model. It was me. The fix was a pattern we built together.

Robert Echevarria