I didn't hire three teams. I built them an architecture.

On April 10 I was trying to clean up my Instagram.

The plan was small. Tighten the cover graphics, build a system that produced consistent reel covers, stop redoing the same template every week. I had a folder of references, a brand palette, and a few rules I kept rewriting from memory. It was supposed to be a one-afternoon job.

What happened instead: an architecture I had been sketching for the writing work got tested for the first time on a visual task. The setup was a separate sandbox with its own governing file, a reference layer, a single brief, and a design session that read only what it needed. I taught the design sandbox the brand rules once. I gave it the brief. I let it run.

Fifty covers came back in minutes. Same palette. Same type. Same cover language. None of them off-brand.

I have been teaching since 1996. I know what fifty hours of design work looks like. I had just watched it finish before lunch.

That was the gateway. I had not been trying to build anything bigger than a tidy Instagram. But once an architecture, taught and tested, can be trusted to execute, the question is no longer what can I delegate. It is what is now worth building.

Twenty-one days later, on May 1, the answer is three working teams, four books shipped or shippable, a new website, and a clear list of the next two teams to build.

This is the operator's account.

What I had been trying to build

The mindset from day one was unromantic: improve GabeYoga online. Specifically, three things.

A new website that reads like the work is actually doing.

A finished e-book, the JDM book, that holds up under scrutiny from bodyworkers who know the source material cold.

A repeatable process that could take the JDM book completion and apply it to the rest of the manuscripts sitting on my drive.

The IG cleanup was meant to be the small first move. It turned into the test that proved the architecture was real.

The shape of the working system

Three Claude projects. Each one named, each one isolated, each one with its own governing file.

Orchestrator (research + delegation)
    Reads across everything.
    Writes briefs and reference files.
    Validates handoffs. Does not write prose. Does not generate images.

Content sandbox (My-Content-Ai)
    Articles, podcast, Instagram, book editing.
    Reads its own CLAUDE.md, CONTEXT.md, _config/REFERENCE.md.
    Writes to known output folders.

Design sandbox (My-Cover-Designs)
    Covers, illustrations, thumbnails, IG.
    Reads design briefs.
    Writes images to known output folders.

The operator (me) sits outside the boxes and validates the final products. The orchestrator delegates and monitors. The two worker sandboxes never see each other's files. Every handoff is a brief.

The reason this works is not novel. It is the same reason JDM clinical work runs on assessment and language before any technique. Each session reads its constraints first. By the time it touches the work, the question of what kind of output am I producing is already answered.

What named what we were doing

I did not invent any of this from scratch. I read.

The framework is Interpretable Context Methodology: Folder Structure as Agent Architecture by Jake Van Clief and David McDermott, published through Eduba at the University of Edinburgh. The protocol they describe is called Model Workspace Protocol (MWP). It is open-source under MIT at https://github.com/RinDig/Model-Workspace-Protocol-MWP.

The core move is simple enough to describe in a paragraph and load-bearing enough that it changed the build:

The filesystem itself becomes the orchestration layer. Numbered folders represent stages. Plain markdown files carry the prompts and the context. One agent reads the right files at the right moment. There are five context layers. A top-level governing file that tells the session where am I. A navigation file that tells it where do I go. A stage file that tells it what do I do. A reference layer that holds what rules apply (the factory). A working-artifacts layer that holds what am I working with (the product).

Reference is internalized as constraints. Working artifacts are processed as input. Mixing them in a single prompt forces the model to sort. Separating them in the folder structure delivers context already organized.

Every output is an edit surface. The human reviews and optionally edits before the next stage runs. Glass-box, not black-box.

Configure the factory once. Each pipeline run produces a new deliverable using the same configuration.

Alongside MWP I worked through Jake Van Clief's course on AI agent orchestration, taught through his Skool community, and refined the architecture three times, drawing on Ari Evergreen's GitHub work and an intuitive sense of where the seams were.

The first refinement separated reference material from working artifacts inside the content sandbox. Voice contracts, brand palette, naming conventions stopped traveling with the draft and lived in their own folder. The second refinement moved the orchestrator out of the worker sandboxes entirely, so research and delegation happened in a context that could read all three projects without contaminating any of them. The third refinement tightened brief format itself: every brief opens with task, context, scope, acceptance, escalation, and a returns-with checklist, so a session that has never seen the project can execute and a future session can verify whether the work actually got done.

Each refinement reduced cycles. Less context per stage. Fewer rounds to a clean output. Lower cost per deliverable.

The learning curve, once the architecture sat in the right shape, was under an hour.

The first real test: a book

The first place I sent the architecture after IG was the JDM book.

Three teams, working chapter by chapter. The orchestrator read the source material and assembled per-chapter briefs. The content sandbox edited prose against a voice contract. The design sandbox produced the anatomical illustration cards. I validated each chapter as it came back.

The technical deep-dive on what that looked like in one specific chapter, the Anatomy Trains correction where the manuscript said seven lines and Myers has twelve, is its own article: I didn't give AI my notes — I built it a context layer. If you want the editing brief, the layer-by-layer build, and the before/after of one chapter, that is the file to read.

What I want to mark here is what the JDM book proved at the architecture level: chapter-by-chapter throughput is not a function of how good the writing model is. It is a function of how clean the briefs are. The briefs were clean because the reference layer was right. The reference layer was right because the governing files told each sandbox what counted as authoritative before it loaded the first sentence.

What replicated

Once the JDM book was done, the same process applied, without rebuilding the architecture, to three more manuscripts.

A book on why most teachers lose the room. A book on why demonstrating is making teachers worse. A yin yoga book in active build. The process was identical: editing briefs, voice contract, layout, cover concepts in A/B pairs. Three teams running the same playbook. Different domain, same architecture.

The work that previously meant find a designer, brief them, wait, revise, wait again was now a sequence of briefs, validations, and known outputs. The investment was the architecture. The deliverables came out of the architecture as a function of how clearly the next request was specified.

The peak: three teams in one pipeline

The clearest moment that this was working showed up in the most demanding visual task I had ever asked anyone to do.

Three mapping systems on the human form, in one consistent visual language. Traditional Chinese Medicine meridians. Thai Sen lines. Thomas Myers' Anatomy Trains. Each system has its own anatomical logic, its own naming, its own lineage. I had been collecting reference for years. The illustration set existed in pieces, in photographs of textbook plates, in my own drawings. None of it had ever sat together.

This is where the three teams crossed lanes.

The research-orchestrator read the source material across all three traditions and produced a master reference: pathway, anatomy, naming, and the cross-references where two traditions describe the same line in different vocabularies. The content sandbox wrote the card text, clinical, in the book's voice, ready to drop into a layout. The design sandbox rendered the illustrations on the human form, card by card, against a fixed visual system.

No one team could have produced that set alone. The research team does not write card copy. The content team does not produce illustrations. The design team does not adjudicate which Anatomy Trains line corresponds to which Sen pathway. Three teams in one pipeline, with the operator validating the output of each, produced a body of work that would have required a year of coordination through email and design contractors and probably never have shipped at all.

What that set of illustrations now does downstream: it sits in the JDM book as the visual chapter. It powers the landing page for clinical sessions. It becomes the source for Instagram carousels that teach one line at a time. It becomes the reference photographer for any future course on cross-system bodywork. Built once, used many times. The reference layer principle, applied to images.

That was the moment the architecture stopped being an experiment.

What's next

Two more teams. Same architecture, new domains.

A Facebook ads team. The brief layer becomes the campaign layer; the reference layer becomes the audience and offer documents; the design sandbox already knows the brand. Most of the build is configuring the factory, not training the writers.

A coaching-funnel team for client intake and follow-up. The reference layer there is the JDM clinical material plus the offer pages. The content sandbox already speaks in voice. The orchestrator does the routing.

Both teams will be built the same way the first three were: governing file, reference layer, briefs, validation. The cost of building team four and team five is dramatically lower than the cost of building team one. That is not because Claude has improved. It is because the architecture has been refined to the point where standing up a new sandbox is a configuration step, not a project.

The thesis

The architecture is the asset.

Not the model. Not the prompt. Not the writer at the keyboard. Once the folder structure, the governing files, the reference layer, and the brief format are in place, output becomes a function of how clearly the next request is specified, and almost nothing else.

Twenty-one days, from a small Instagram cleanup to three working teams, four books, a new website, and the next two teams already scoped.

Same operator. Same hours in the day.

Configure the factory. Validate the output. Trust the structure.

If you want to experience the method that all of this writing serves, the JDM session page is here: gabeyoga.com/therapy