You have the pieces. Decomposition works. Voice governance works. Each practice produces better output on its own. But you're managing them manually, every session, and the overhead is eating the gains.
Every time you sit down to work, you have to remember which protocols to load, which lenses to run, which hierarchy marks to check. The practices are good. The manual orchestration is not. You spend twenty minutes setting up what should happen automatically, and some sessions you skip steps because you're tired. The system works when you work it. It doesn't work itself.
Individual practices (decomposition, inversion, lenses, voice, hierarchy) are powerful alone but fragile when stitched together by hand. A coordinator is infrastructure that embodies your workflow: it loads the right protocols, sequences the right steps, and enforces the right constraints without you remembering to do each one.
This is where the five practices become a unified system. A coordinator doesn't just run your tools in order. It knows which tool is appropriate for which stage of work, what each tool needs as input, and what governance applies at each step. The result is a custom AI working environment built specifically for how you think and what you make.
A working coordinator for your own practice. You'll take the five systems you built in Courses 01-05 (decomposition workflow, input inversion pipeline, lens array, voice protocol, semantic hierarchy) and wire them into a single infrastructure that runs your creative process. The coordinator is yours. It reflects your workflow, your standards, your voice. It is the capstone because it requires everything that came before it.
Deliverable: A working coordinator that orchestrates your full practice, tested on a real project from start to finish.
Capstone: student-designed system. Instructor provides architectural patterns, not prescriptions.
You have five practices that work. You don't have a map of where they live. Some run at the start of a project, some run at the end, some should run continuously. Some depend on each other. Some are independent. Right now you hold all of that in your head, and some sessions you forget a step.
You start by mapping your current workflow: where does decomposition happen? Where does voice governance kick in? Where do lenses evaluate? Where do savepoints fire? Where does the dump enter the pipeline? You draw the real picture, not the ideal one. Then you identify the friction: what's manual that should be automatic? What's disconnected that should be wired together? What runs in sequence that could run in parallel?
By the end of the week you have a coordinator blueprint. It specifies which practices run independently (voice sampling and lens calibration don't need each other), which run in sequence (the dump has to happen before decomposition can structure it), and where governance checkpoints sit. The blueprint is yours. It reflects your work, not a generic template.
Deliverable: A coordinator architecture diagram mapping your five practices, their dependencies, and their orchestration sequence.
Capstone: student builds the working system. Instructor provides interface principles, not implementation.
The blueprint becomes infrastructure. You build atomic skills (one objective each) and the orchestration layer that sequences them. This is where the five courses converge into one system.
You wire voice protocol into the generation pipeline so every output runs through your constraints before the first word lands. You wire your lens array into the evaluation pipeline so assessment is decomposed and automatic, not a manual checklist you run when you remember. You wire savepoints into context preservation so cognitive turning points are captured as they happen, not reconstructed after the fact. You connect input inversion (the dump) to the downstream tools so raw thinking flows into structure without a formatting step in between.
Each connection is a real interface. The quality of the coordinator depends on the quality of those interfaces. A poorly fitted prosthetic fights the body it's attached to. A well-fitted one disappears into use. You are building the prosthetic that fits your practice.
This is not a prototype. This is your working system. You will use it tomorrow.
Deliverable: A working coordinator with atomic skills wired through an orchestration layer, tested on component-level tasks.
Capstone: student runs and iterates the system on real work. Instructor provides diagnostic patterns, not fixes.
You run your coordinator on a real project, end to end. Not a test case. Not a simulation. A project you need to finish. The coordinator handles orchestration: loading protocols, sequencing tasks, enforcing constraints, preserving context. You handle direction, judgment, and synthesis.
Some of it will hold. Some of it will break. You identify where: maybe the voice protocol fires too late in the pipeline. Maybe two lenses that you assumed were independent actually need to run in sequence. Maybe a savepoint trigger is too aggressive and you're drowning in context markers that don't mean anything. Maybe a skill you built is doing two things and needs to be split.
You refine. Add what's missing. Adjust the orchestration. Remove what doesn't earn its place. This is where the scaffold principle applies: if a tool has to stay permanently loaded to keep the system running, it's a dependency, not structure. Structure is what remains after the scaffolding comes down. Your coordinator should feel like the way you work, not like overhead you maintain.
In December 2024, before the term "coordinator" existed, the proto-version of this was already being built: a custom GPT wired to a database as a single source of truth for a novel project. Same instinct. Same problem. The tooling has matured. The need was always there.
Deliverable: A refined coordinator system, tested end-to-end on a real project, with a written assessment of what held, what broke, and what was removed.
Same practitioner. Same skills. One managed manually. One coordinated.
October 2024: a designer tries to build a single Custom GPT that does everything: design feedback, code help, voice guidance, knowledge retrieval from uploaded books. All in one prompt context. March 2026: the same designer, same capabilities, different architecture.
"I want it to have expertise in my tech stack and in graphic design, illustration, ux/ui design. I want to upload design history books, art/illustration books. I'd like code snippets, design feedback, brainstorming, and general project support almost like having a digital mentor."
One tool holding design evaluation, code generation, voice matching, and knowledge retrieval simultaneously. No separation. Compound objectives degrade. The practitioner carries all the routing logic.
"Every skill I build has one objective, one output, no knowledge of other skills. The coordinators dispatch skills in parallel where they're independent, sequentially where one depends on another's output. The model never receives twelve goals at once."
73 single-purpose skills. 7 coordinators. Each skill focused. The orchestration handled by the system, not the practitioner's memory.
This course uses project-based capstone learning. There is no way to teach coordinator building in isolation because the coordinator is the integration of everything. You build a real system for a real project using real tools you built in previous courses. The course provides architecture patterns and design principles, but the implementation is entirely yours. The capstone model works here because the skill being tested is synthesis: can you take five independent practices and compose them into a coherent whole that reflects your specific needs? That question can only be answered by doing it.
This course draws on all six published whitepapers. The coordinator is where the full methodology becomes a unified practice. The capstone paper is Prosthetic Cognition: AI as cognitive extension.
This course is in development. $499 per course. Payment plans available on all courses. Completion of Foundations and Courses 02-05 is required. See the full curriculum.
$499. Requires Foundations + Courses 02-05. Payment plans available.