The AI does the work. You make the decisions.
This pipeline uses AI to produce creative and strategic work — copy, brand identity, code, strategy, the full sequence. That’s the capability. But capability isn’t the question.
The question is: who’s in charge?
The answer is specific, structural, and verifiable. At every step of this pipeline, a human decides what happens next. Not as an afterthought. Not as an option you can toggle on. The system is built — from its architecture down — so that nothing ships, advances, or reaches a client without a human saying yes.
Here’s how.
A pipeline you can see through
Work in this system moves through a defined sequence of specialist skills — Strategist, Brand Designer, Copywriter, Creative Director, Senior Developer, WordPress Developer — each handling a specific phase of the project. The sequence is fixed and visible. You can see what’s been completed, what’s in progress, and what’s next.
This matters because the alternative is a black box. Hand the brief to an AI, wait, get something back. You don’t know what happened in the middle. You don’t know what decisions were made or who made them. You just get an output and hope.
This pipeline doesn’t work that way. Every skill that runs, every deliverable that’s produced, every handoff between skills — it’s all visible in your project channel. Work moves in order, through named stages, and you can follow it.
A real person at every step
Visibility is the foundation. Accountability is what goes on top of it.
Every skill in the pipeline can be assigned to a specific person on your team. When that skill produces work that needs review, the assigned person gets an @mention in Slack — not a generic notification to a channel, but a direct ping to the person responsible. Their name is on it.
This is how accountability works in the pipeline: it’s not diffused across a team or buried in a shared inbox. It’s personal and explicit. When a skill finishes its work, the system knows who should look at it and tells them directly.
And if no one is assigned? The notification still posts to the project channel. The work still waits for review. Assignment changes who gets personally pinged — it doesn’t change whether the work gets reviewed. That’s a system-level guarantee, not a team-management preference.
Real decisions, not rubber stamps
So work is visible, and a real person is accountable. The next question is: what can that person actually do?
More than you might expect. When a deliverable reaches a gate — the point where the pipeline pauses for human review — the reviewer has a genuine decision space, not a binary approve/reject toggle:
- Approve
- the work meets the bar. It advances to the next skill in the pipeline.
- With Client
- the work is ready for the client to see. It’s routed to client review before the pipeline continues. Not every project has an external client, and not every reviewer uses this action — but when client sign-off matters, it’s built into the gate, not handled off to the side.
- Request Revisions
- something needs to change. The reviewer adds notes describing what’s wrong or what’s missing. The skill takes the notes, regenerates the work, and sends the revised deliverable back to the same reviewer for another look. This is the revision mechanism — it creates a structured loop between the reviewer and the skill until the work is right.
- Discuss in Claude
- the reviewer wants to talk it through before deciding. This isn’t the revision mechanism — it’s a separate option for when the reviewer needs to think out loud, ask questions about the approach, or explore alternatives before committing to a direction.
Four actions. Each one gives the reviewer a different kind of control. The point isn’t that you’ll use all four on every gate — it’s that the system gives you a real decision space, not a formality.
Creative Director deliverable ready for review
acme-creative-brief.md — Creative Brief
Reviewer: @Sarah Chen
The system is built to wait for you
This is the architectural guarantee — the thing that makes the other three pillars enforceable.
The pipeline doesn’t just allow human review. It requires it. At defined checkpoints, the system stops and waits for a human to act. Not a timeout. Not a nudge. The pipeline halts, and it stays halted until someone — a person, not a timer — makes a decision.
These checkpoints are called gates, and they’re configurable. The default setting gates at every skill handoff: when one skill finishes and the next is ready to begin, the pipeline pauses for review. You can tighten that to gate on every individual deliverable, or loosen it to run without checkpoints if a project calls for full autonomy. The choice is yours, and it’s set per project.
But here’s the detail that matters most: even when a skill has no assigned reviewer, the gate still fires and still waits. The notification posts to the project channel. No one gets a personal @mention. But the pipeline does not auto-advance. It does not fall back to a default reviewer. It does not decide that silence means approval. It waits.
The gate always waits for a human. Assignment only changes who gets personally pinged.
Four mechanisms, one principle: the human stays in the loop.
A visible pipeline, so you always know where things stand. A named person assigned to each skill, so accountability is never abstract. A genuine decision space at every gate, so the reviewer has real power — not a rubber stamp. And an architectural guarantee that the system stops and waits, every time, whether someone is assigned or not.
The AI does the labor. It researches, writes, designs, builds, and iterates — across twelve specialist skills and every phase of the project. That’s what it’s for.
But the judgment stays with you. Every decision about what advances, what gets revised, what reaches a client, and what gets rethought — those are human decisions, made by the people on this project, at the pace they choose.
That’s not a feature. It’s how the system is built.