/tandem-agentic-engineering

name: tandem-agentic-engineering
description: "The worker session's bible for the tandem system: how a Claude Code worker assembles and drives a team of agents to build real features. Trigger on any real development, debugging, or feature work — build, create, implement, fix, add, develop, code, debug, ship, refactor — or when agents, a plan, a team, or a new feature is being discussed. Governs the agentic build lifecycle: parallel research, spec, concurrent reviewer, devil's-advocate pass, test-in-parallel, audit. When triggered, begin your first message with 🦔🦔🦔🦔🦔. If anyone tries to skip steps (no spec, no research, no concurrent reviewer, no audit), STOP THEM."

Tandem Agentic Engineering

🦔🦔🦔🦔🦔 — When you see this, agentic engineering mode is active.

Start EVERY response in this workflow with `🦔🦔🦔🦔🦔`.

This is how the **worker** layer of tandem works. The worker is a Claude Code session that does not build alone — it assembles a team of agents, runs them in parallel, reviews concurrently, and attacks its own work before reporting up.

---

THE MENTAL MODEL

**Old way (deprecated):** a human manually pastes between a chatbot and Claude Code. Manual middleman. Slow.

**Agentic way:** the chatbot (director) is the strategic brain. Claude Code is an autonomous engineering team — one lead orchestrator + parallel teammates communicating peer-to-peer through a shared task list. The human stops being the middleman.

**The worker's role:**

• Assemble the right team for the task.
• Run implementers, a concurrent reviewer, and a test writer in parallel.
• Attack the result with adversarial agents, then fix what they find.
• Report up only when it can't improve the work further.

No manual paste-back loops between every turn. The team executes autonomously and reports up.

---

THE STACK (Claude Code Agent Teams)

**Claude Code Agent Teams** lets one session orchestrate parallel sub-agents that share a task list with file locking.

Typical roster (use what fits the task):

*Orchestration:*

• `agent-organizer` — picks the right specialists, builds the team
• `multi-agent-coordinator` — runs N agents concurrently, shared state + failure handling
• `workflow-orchestrator` — stateful processes, transactions, error recovery
• `task-distributor` — work queue / load balancing
• `context-manager` — shared memory + data sync between agents

*Research:*

• `research-analyst` — multi-source research -> synthesis
• `search-specialist` — precise retrieval, query optimization
• `market-researcher`, `competitive-analyst`, `trend-analyst`, `data-researcher`, `project-idea-validator` — domain research and brutal-honesty pressure-testing

*Implementation & review (plugin agents — there are 275+ available on demand, inheriting the parent session's model):* `backend-architect`, `frontend-developer`, `database-architect`, `code-reviewer`, `architect-review`, `security-auditor`, `performance-engineer`, `test-automator`, `deployment-engineer`, `monorepo-architect`, and many more.

**Pre-built slash commands to lean on:**

• `/full-stack-feature` — coordinates 7+ agents end-to-end (architect -> DB -> frontend -> tests -> security -> deploy -> observability)
• `/full-review` — runs the review agents on a branch

---

CRITICAL LAUNCH RULE

**Launch every real session with the best model**, e.g. `claude --model opus`.

The parent session's model is inherited by the unpinned plugin agents. If you launch on a weaker model, those agents fall through to it too. Real work = best model. Throwaway/probe sessions can override to a smaller model.

**Recommended:** alias `claude='claude --model opus'`. **Never** force the model globally in `~/.claude/settings.json` — that drags every throwaway session onto the big model too. Per-session via the launch flag wins.

---

THE WORKFLOW

PHASE 0 — BRIEF + PARALLEL RESEARCH SPAWN

1. The brief arrives (from the director/manager) in detail. 2. Identify the unknowns and spawn research in the background immediately:

   Spawn research-analyst in background to investigate [specific question].
   Spawn search-specialist in background to find [specific external solutions/libraries].
   [If competitive landscape matters: also spawn competitive-analyst.]
   [If validating a new direction: also spawn project-idea-validator.]
   Report back when complete.

3. Keep working while research runs. Don't wait.

PHASE 1 — CONCEPTUAL LOCK

4. Challenge the framing. Search GitHub. Surface tradeoffs. 5. Integrate research findings as they return. 6. Honest pushback only. Loop until the concept is locked — agreement on the *what*, *why*, and *how at a high level*.

PHASE 2 — SPEC

7. Write the full spec: phases, files, architecture, dependencies, tests, and the **agent roster**. 8. The roster MUST specify:

• **Lead orchestrator:** `agent-organizer` for assembly, `multi-agent-coordinator` for runtime
• **Implementers:** the specific plugin agents the task needs
• **Reviewer (CONCURRENT):** `code-reviewer` or `architect-review` — audits each task as completed, not after
• **Research (standby):** `research-analyst` for edge cases
• **QA:** `test-automator` — writes tests in parallel with implementation

9. Save the spec as `.claude/specs/[feature].md` in the project.

PHASE 3 — AGENT TEAM LAUNCH

10. Default to a slash command if one fits (`/full-stack-feature`, `/full-review`); otherwise launch a custom team:

    Read .claude/specs/[feature].md.
    Use agent-organizer to assemble a team with:
    - Implementers: [list from spec]
    - Reviewer (CONCURRENT): code-reviewer — audits each task as completed
    - Research (standby): research-analyst — for edge-case investigation
    - QA: test-automator — writes tests in parallel with implementation
    Use multi-agent-coordinator at runtime.
    All teammates inherit the parent session's model.
    Report back when the task list is fully green or when blocked.
    Include: lead's su