← → or click to navigate
/team-config

Assemble your
agent squad.

One command to configure an entire agent pipeline with role-based personas, sequential handoffs, and human checkpoints.

Drop one file into any repo. Run /team-config. Build.

THE PROBLEM

Agents are powerful.
But unstructured agents are chaos.

🚨 No clear handoff between "spec" and "code" and "review"
🔄 Agents redo each other's work or skip critical steps
💭 No record of why decisions were made
🔧 Setting up teams manually every time is tedious

THE SOLUTION

A structured pipeline
that runs itself.

1. Each agent has a specific role and a distinct persona
2. Stages run sequentially — each one feeds the next
3. You choose where to insert human checkpoints
4. A Scribe silently documents every decision and tradeoff
5. Save config, reload it next time with /team-config --load

THE SQUAD

Eight roles. Eight personas.

🏗
The Architect
Turns ideas into specs no one can misread
"You measure twice because cutting twice is expensive."
🔍
The Skeptic
Pokes holes in blueprints before code is written
"I'd rather find the holes now than in production at 2 AM."
⚒
The Test Smith
Writes tests first. That's the religion.
"A failing test is a promise."
🧪
The Test Critic
Makes sure the tests actually prove something
"The worst test is one that passes when the code is broken."
🔨
The Builder
Minimum code, maximum correctness
"Over-engineering is a bug."
🛡
The Gatekeeper
Nothing ships until this passes review
"'It works on my machine' means nothing."
⚖
The Judge
Final verdict: did we build what we promised?
"I'm not here to be impressed. I'm here to verify."
📝
The Scribe
Watches everything. Writes down what matters.
"Every word earns its place or gets cut."

THE PIPELINE

Each stage feeds the next.

Sequential handoffs. No ambiguity about who does what.

🏗Architect
→
🔍Skeptic
→
⚒Test Smith
→
🧪Test Critic
→
🔨Builder
→
🛡Gatekeeper
→
⚖Judge
📝 The Scribe watches the entire flow, documenting decisions in real time

INTERACTIVE SETUP

You pick.
It builds.

The command walks you through a few quick questions, then assembles and launches the entire pipeline automatically.

Q1 What are you building?
Q2 Pick your squad
Q3 Set your checkpoints
Q4 Add custom roles?
claude
$ /team-config

Pick your squad. Who's on the roster?

◆The Architect
◆The Skeptic
◆The Test Smith
◇ The Test Critic
◆The Builder
◆The Gatekeeper
◇ The Judge
◆The Scribe

HUMAN IN THE LOOP

You decide where to
pause and review.

Checkpoint stages wait for your approval before the pipeline continues.

🏗 Architect
auto
→
🔍 Skeptic ✋
checkpoint
→
⚒ Test Smith
auto
→
🧪 Test Critic
auto
→
🔨 Builder
auto
→
🛡 Gatekeeper ✋
checkpoint
→
⚖ Judge
auto

Example: review the spec after The Skeptic, and the code after The Gatekeeper.

THE SCRIBE

Every decision,
documented.

The Scribe watches the entire pipeline and produces a session log designed to be absorbed in 60 seconds.

No fluff. No filler. No "in conclusion."

"Every word earns its place or gets cut."

session-notes.md

Session Notes — Auth Refactor

Compiled by The Scribe

The Blueprint

Decision: JWT with refresh tokens | Why: Stateless scales better than sessions

Tradeoff: No instant revocation | OK because: 15-min expiry is acceptable

The Skeptic's Take

Flagged: No rate limiting on refresh | Resolution: Added to spec

The Build

Approach: Middleware + decorator pattern

Not this: Custom auth backend | Because: framework middleware is sufficient

For Next Time

- Consider token rotation for long sessions

- Evaluate OAuth2 for third-party integrations

PORTABLE

One file. Any repo.

Drop it in. Run the command. Everything else is generated.

.claude/
  commands/
    team-config.md you add this
  agents/ generated at runtime
    team-architect.md generated
    team-skeptic.md generated
    team-builder.md generated
    ...
  team-config.json generated
  session-notes.md generated

Generated agent files and config are committed — shared with your team.

REUSABLE

Same squad.
Next session.

Your pipeline config is saved. Reload it instantly, or tweak it before launching.

/team-config --load
Shows your saved lineup, lets you confirm or modify, then spawns.
claude
$ /team-config --load

============================
 LAST SESSION'S LINEUP
============================
Project: Auth system refactor
Squad:   Architect → Skeptic → Test Smith → Builder → Gatekeeper → Judge
Checks: Skeptic, Gatekeeper
Scribe: on
============================

Run it back or switch it up?
◆Run it back — same squad, let's go
/team-config

Assemble. Configure.
Build.

One file. Any repo. Interactive setup.
Sequential pipeline. Human checkpoints. Decision log.

drop into .claude/commands/ and go