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.

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

PHASE 1 — CONCEPTUAL LOCK

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

PHASE 2 — SPEC

1. Write the full spec: phases, files, architecture, dependencies, tests, and the agent roster.
2. 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

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

PHASE 3 — AGENT TEAM LAUNCH

1. 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 summary, reviewer's findings, test results, open questions.

1. The team works autonomously, communicating via the shared task list with file locking.

PHASE 4 — THE INTERNAL PERFECTION LOOP (before reporting up)

1. When the agents finish, the worker does NOT accept it as done. It runs this loop:

• a. Self-review + enforce: review the output; send sloppy or incomplete work back to redo against the spec.
• b. Devil's advocate pass: spawn adversarial agents whose only job is to attack the work — "this breaks under X," "this is mediocre, here's what excellent looks like." Use multiple angles: security, performance, UX, edge cases, simplicity.
• c. Test relentlessly: run the full suite, write new tests for every weakness the devil's advocates found, run again.
• d. Improve beyond the ask: what would make this exceptional, not just correct? Add it (within scope).
• e. Loop a->d until the worker can't find a single thing to improve. Minimum 3 internal loops.

1. Only then report up to the manager with: the diff, the devil's-advocate findings already fixed, and test results.

PHASE 5 — REPRODUCE -> FIX -> VERIFY

1. Reproduce: run the failing test/command, confirm the bug is real.
2. Fix: route a targeted fix to a specific teammate through the existing task list, not a fresh session.
3. Verify: re-run the same test, then the full suite. Confirm nothing else broke.

DESIGN RULES (UI must look human-made, not "AI ugly")

Bad AI design is a failure condition, not an acceptable default.

1. Design UI like a human, from real references. Before building any user-facing UI, pull real, human-made design references and apply the principles (spacing, hierarchy, type scale, restraint), not a copy. Banned "AI ugly" tells: generic centered-everything layouts, purple/blue gradient slop, emoji-as-icons, inconsistent spacing, three different fonts, default-framework look with no taste, cramped or floating elements, fake-depth drop shadows everywhere. The reviewer/devil's-advocate pass includes a design critique — if it looks AI-made, it goes back.

1. Generated media must look obviously real. If the product needs generated images/video, the hard bar is that it looks like a real photo/real footage a human shot. AI tells (warped hands, plastic skin, melted text, uncanny faces, that "AI sheen") = rejected and regenerated. The devil's-advocate pass checks media too: "would a normal person clock this as AI?" If yes, redo it.

RULES — HOLD EVERY LAYER ACCOUNTABLE

• No agent team launch without a spec. No "just figure it out."
• Launch with the best model for real work.
• Always spawn parallel research in Phase 0 if any unknown exists.
• Reviewer runs CONCURRENTLY with implementers. Never sequential.
• Lead orchestrator must report up. No silent execution.
• Reproduce -> Fix -> Verify still applies. Agent teams don't replace bug discipline.
• Spec file per feature in .claude/specs/[feature].md.
• No solo runs for real features. If it deserves a spec, it deserves a team.
• Never force the model globally in settings.json. Per-session launch flag only.
• Run the perfection loop before reporting up. One build pass is not done.

ACCOUNTABILITY TRIGGERS

WHEN NOT TO USE THIS

Skip the full agentic workflow for one-line fixes, typos, renames, trivial config changes, or throwaway experiments. For those, instruct Claude Code directly — no spec, no team. Reproduce -> Fix -> Verify still applies to any bug.

EMOJI SIGNAL

🦔🦔🦔🦔🦔 = Agentic engineering active. Appears at the START of every message in this workflow.