Dream Team

Source of truth for all Claude Code agents and commands. Install once, use everywhere.

What's in the box

7 agents, each with a matching /command, plus a /team orchestrator and /code-review for automated PR reviews.

Coach K (the orchestrator) runs on claude-opus-4-7. All agents are pinned to specific model builds rather than floating aliases so eval baselines stay reproducible across versions. Kobe and Magic carry memory: user and learn across sessions.

Cross-cutting agent features

• Output schema — structured fields Coach K validates before handoffs (prevents agents talking past each other).
• Escalation protocol — each agent knows when to stop and ask instead of guessing.
• Confidence assessment — self-reported confidence + assumptions, so downstream agents can calibrate trust.
• Turn budget — hard limits force agents to ship instead of researching forever.

When to use what

Spec-Driven Development (SDD)

dreamteam is spec-driven: the spec is the contract, and every /team session produces one at docs/spec-<topic>/spec.md. The twist vs. single-author SDD tools (GitHub Spec Kit, AWS Kiro, Cursor Plan Mode): the spec is multi-authored, and the whole feature lives in a single folder — intake, per-agent artifacts, and the consolidated spec all together.

• You author intent in docs/spec-<topic>/intake.md — Problem Statement, Out of Scope, constraints. Coach K drafts from your one-liner, asks for an optional Linear/tracker reference via AskUserQuestion and bakes it into the intake's Tracker: header, then you confirm or rewrite via AskUserQuestion. If you wrote the intake offline first, dreamteam detects it and skips the draft.
• Each agent writes their own artifact under docs/spec-<topic>/: Bird → domain.md (acceptance criteria), MJ → architecture.md (decisions + NFRs), Pippen → operations.md (readiness criteria), Drexler → scope.md (what was kept out), Kobe → review.md (quality findings).
• Magic synthesises everything into the final docs/spec-<topic>/spec.md — normalising terminology across sections (e.g. Bird's "Customer" vs Pippen's "Tenant") and flagging contradictions explicitly rather than silently picking one.
• You sign off on the synthesised spec before the session ends. If it doesn't match intent, you reject and the spec is re-synthesised.

Each artifact preserves the authoring agent's voice, so the spec isn't Coach K's paraphrase of agent output — it's the agents' actual work, stitched together. The hook at scripts/check-plan.ts advises (never blocks) when Edit/Write runs without an intake.md present.

/team — Coach K Orchestration

Coach K coordinates the team in three modes:

• Quick Fix (subagents) — sequential pipeline for bugs and small features: you author intake → Bird → Shaq → Kobe + Drexler (parallel) → Magic synthesises final spec → you sign it off. Coach K curates a focused brief per agent instead of dumping all prior outputs. If Kobe finds bugs or Drexler finds bloat, Shaq fixes and reviewers re-verify — no fixes are skipped.
• PR Review (parallel subagents) — Bird + MJ + Kobe review the diff in parallel, Coach K synthesizes to docs/PR-<number>-review.md. All gh commands are READ-ONLY; nothing is posted to GitHub.
• Full Team (agent teams) — 7 independent sessions for new features and complex multi-file work. You author intake at docs/spec-<topic>/intake.md → Phase 1 Bird + MJ analysis (concurrent, each writing their own artifact: domain.md, architecture.md) → Magic handoff brief → Coach K checkpoint + user approval → Shaq implements → Kobe + Pippen + Drexler review (parallel, writing review.md, operations.md, scope.md) → Magic consolidates all artifacts into the final docs/spec-<topic>/spec.md → you sign it off. Checkpoints saved to disk so earlier work isn't lost. Requires CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1; falls back to Quick Fix if disabled.

Git safety: no agent ever commits or pushes. The user controls all git operations.

Retros: every /team run produces a checkpoint in docs/checkpoint-<topic>.md and an HTML retro in reports/retros/ with team metrics (escalations, confidence, fix-verify loops).

/code-review — Automated PR Review

Based on the official Claude Code code-review plugin, adapted for local-only output. Launches CLAUDE.md-compliance + bug-detector agents in parallel, plus validation agents to reduce false positives. Output stays in the terminal — nothing is posted to GitHub.

/code-review 42        # Review PR #42
/code-review           # Review current branch's PR

Installation

git clone <this-repo> ~/Github/Bondarewicz/dreamteam
cd ~/Github/Bondarewicz/dreamteam
bun scripts/install.ts

The installer backs up existing files, then copies agents to ~/.claude/agents/ and commands to ~/.claude/commands/. Re-run bun scripts/install.ts after any edit and restart Claude Code.

For Full Team mode, add to ~/.claude/settings.json:

{ "env": { "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1" } }

Models & Tuning

The model: field in each agents/*.md is the source of truth. Edit it and run bun scripts/install.ts to apply.

Strategy: quality-first, with each agent on the model matching its reasoning demands. Pinning every agent to a specific build (e.g. claude-opus-4-7) lets us run full evals against an identical config — the only variable between runs is the model version.

A/B a single run without editing frontmatter: bun evals/src/cli.ts --trials 3 --model claude-opus-4-7. The flag only affects phase-1 agent runs; the Coach K scoring judge stays on the default so comparisons share a baseline.

Effort note: Claude Code subagent frontmatter does not expose a per-agent thinking/effort dial. Effort is governed globally by adaptive thinking — do not set CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1. To raise or lower an agent's effective effort, choose a heavier/lighter model or tighten the prompt.

Turn limits: shaq runs at maxTurns: 100 (it writes code and iterates); drexler at 30 (search-only, no implementation); the rest at 50.

Tuning quick reference:

Web Eval Viewer

web/ is a Bun server that serves eval results from SQLite (data/dreamteam.db) and auto-imports JSON results from evals/results/ on first run.

cd web && bun install && bun run start    # opens http://localhost:3000
bun run dev                               # hot reload
PORT=8080 bun run start                   # change port

Eval scenarios can also be exported to Anthropic Workbench via bun evals/src/workbench-export.ts <agent>. See evals/README.md.

Miro Integration

The Dream Team integrates with Miro via MCP. Agents can read board context, create diagrams (flowchart, UML, ER), write documents, and build tables — turning analysis into visual artifacts.

Setup:

claude mcp add --transport http miro https://mcp.miro.com
claude mcp list
claude mcp authenticate miro

Example — DDD event storming from a Miro board:

/team come up with implementation plan for https://miro.com/app/board/<BOARD_ID>/

Bird + MJ read the board and produce domain + architecture analysis; Coach K writes back event storming flowcharts, service decomposition diagrams, sequence diagrams, and document cards. See the demo board.

/eventstorming — Domain Modeling on Miro

Builds a Brandolini-style Event Storm directly on a Miro board, using the canonical colour notation and build order. Requires the Miro MCP (see above).

Variants: as-is (current system), to-be (target design), or both (side-by-side frames).

/eventstorming as-is checkout flow                    # AS-IS Event Storm
/eventstorming to-be unified order pipeline           # TO-BE Event Storm
/eventstorming both payment refactor                  # Both, in adjacent frames
/eventstorming                                        # Prompts for variant + scope
/eventstorming --recipe                               # Print the notation reference, no board

Returns the board URL plus a one-paragraph summary (pivotal events, bounded contexts, hot spots). If docs/eventstorms/ exists, the summary is also saved there as a <slug>-<variant>.md file — Miro URLs rot, a checked-in summary survives. Full notation, colour overrides, and build recipe live in commands/eventstorming.md.

Context7 Integration

The Dream Team integrates with Context7 via MCP. Agents (especially Shaq and MJ) fetch up-to-date, version-specific library docs before writing code — preventing hallucinated APIs and outdated patterns from training data.

Setup:

claude mcp add --transport http context7 https://mcp.context7.com/mcp \
  --header "CONTEXT7_API_KEY: <your-key>" \
  -s user
claude mcp list   # should show: context7 ... ✓ Connected

Get a key at https://context7.com. The key is stored in ~/.claude.json (User scope) — never commit it to the repo. Restart Claude Code after adding so the new tools register.

Example:

Use Context7 to fetch current Drizzle ORM schema syntax, then add a users table to db/schema.ts.

Agents call mcp__context7__resolve-library-id → mcp__context7__get-library-docs before writing. See docs/context7-integration.md for per-agent benefit assessment and tool-config changes.

Built-in Tension (by design)

• You vs Agents — author of intent vs authors of artifacts (SDD: intake.md is yours, everything else is theirs)
• Bird vs MJ — correctness vs elegance
• Kobe vs Shaq — quality vs speed
• Drexler vs Shaq — deletion vs addition (maintenance cost watchdog)
• Magic: preserve voice vs normalise terminology — keep each agent's section faithful, but resolve cross-section drift before the spec ships
• Coach K vs everyone — shipping vs perfection

The tension prevents groupthink.

License

MIT — see LICENSE.

Disclaimer

Agent names and jersey numbers are used affectionately as a framing device. This project is not affiliated with, endorsed by, or sponsored by the NBA, USA Basketball, the named players or their estates, Chuck Daly's estate, or Coach Mike Krzyzewski.