Agent Teams Guide for MyClaude Plugin Suites¶

10 ready-to-use team configurations with 20 variants, leveraging 25 MyClaude agents + 18 official plugin agents across 4 suites.

v3.3.0: Consolidated from 27 teams to 10 teams with a variant system (--var MODE=x). Zero function loss — every capability from every absorbed team is reachable via a variant. 20 aliases provide backward compatibility.

Prerequisites¶

Enable agent teams (experimental) in your settings:

// ~/.claude/settings.json
{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

Agent Inventory¶

Suite	Agent	`subagent_type`	Specialization
agent-core	orchestrator	`agent-core:orchestrator`	Workflow coordination, team assembly
	reasoning-engine	`agent-core:reasoning-engine`	Chain-of-Thought, prompt design
	context-specialist	`agent-core:context-specialist`	Memory, context management
dev	software-architect	`dev-suite:software-architect`	Backend, API, microservices
	app-developer	`dev-suite:app-developer`	Frontend, mobile, React/Next.js
	systems-engineer	`dev-suite:systems-engineer`	C/C++/Rust, CLI tools, low-level
	devops-architect	`dev-suite:devops-architect`	Cloud, K8s, Terraform
	sre-expert	`dev-suite:sre-expert`	Observability, SLOs, incidents
	automation-engineer	`dev-suite:automation-engineer`	CI/CD, GitHub Actions, Git
	debugger-pro	`dev-suite:debugger-pro`	Root cause analysis, log correlation
	documentation-expert	`dev-suite:documentation-expert`	Tech writing, API docs
	quality-specialist	`dev-suite:quality-specialist`	Code review, security audit, testing
science	jax-pro	`science-suite:jax-pro`	JAX, NumPyro, Bayesian inference
	neural-network-master	`science-suite:neural-network-master`	Deep learning, Transformers, Flax
	ml-expert	`science-suite:ml-expert`	Scikit-learn, MLOps, XGBoost
	pinn-engineer	`science-suite:pinn-engineer`	PINNs, neural operators, inverse PDEs
	python-pro	`science-suite:python-pro`	Python systems, packaging
	research-expert	`science-suite:research-expert`	Scientific methodology, papers
	simulation-expert	`science-suite:simulation-expert`	Physics simulation, MD
	statistical-physicist	`science-suite:statistical-physicist`	Stat mech, stochastic dynamics
	nonlinear-dynamics-expert	`science-suite:nonlinear-dynamics-expert`	Bifurcation, chaos, SINDy/UDE
	julia-pro	`science-suite:julia-pro`	Julia HPC, SciML
	julia-ml-hpc	`science-suite:julia-ml-hpc`	Julia ML/DL/HPC, Lux.jl, CUDA.jl
	sci-workflow-engineer	`science-suite:sci-workflow-engineer`	Scientific LLM workflows, RAG, codegen

Official Plugin Agents¶

Plugin	Agent	`subagent_type`	Specialization
pr-review-toolkit	code-reviewer	`pr-review-toolkit:code-reviewer`	Style, guidelines, best practices
	silent-failure-hunter	`pr-review-toolkit:silent-failure-hunter`	Error swallowing, bad fallbacks
	code-simplifier	`pr-review-toolkit:code-simplifier`	Clarity, maintainability
	comment-analyzer	`pr-review-toolkit:comment-analyzer`	Comment accuracy, rot detection
	pr-test-analyzer	`pr-review-toolkit:pr-test-analyzer`	Test coverage gaps
	type-design-analyzer	`pr-review-toolkit:type-design-analyzer`	Type invariants, encapsulation
feature-dev	code-explorer	`feature-dev:code-explorer`	Execution path tracing
	code-architect	`feature-dev:code-architect`	Feature architecture blueprints
	code-reviewer	`feature-dev:code-reviewer`	Bug, logic, security review
code-simplifier	code-simplifier	`code-simplifier:code-simplifier`	Code clarity and refinement
agent-sdk-dev	agent-sdk-verifier-ts	`agent-sdk-dev:agent-sdk-verifier-ts`	TS Agent SDK validation
	agent-sdk-verifier-py	`agent-sdk-dev:agent-sdk-verifier-py`	Python Agent SDK validation
plugin-dev	agent-creator	`plugin-dev:agent-creator`	Claude Code agent generation
	skill-reviewer	`plugin-dev:skill-reviewer`	Skill quality review
	plugin-validator	`plugin-dev:plugin-validator`	Plugin structure validation
superpowers	code-reviewer	`superpowers:code-reviewer`	Plan adherence review
hookify	conversation-analyzer	`hookify:conversation-analyzer`	Behavior analysis for hooks
product-tracking-skills	tracking-watchdog	`product-tracking-skills:tracking-watchdog`	Proactive tracking coverage monitor

Quick Reference¶

#	Team	Variants	Best For	Agents
1	feature-dev	–	Feature build + review	4
2	debug	triage, gui, numerical, schema, incident	All debugging + incident response	2-4
3	quality-gate	security, full	PR review + security audit	4
4	api-infra	infra, config	APIs + cloud + CI/CD + config	3-4
5	sci-compute	bayesian, julia-sciml, julia-ml, dynamics, md-sim, desktop, reproduce	All scientific computing	4
6	modernize	–	Legacy migration + refactoring	4
7	ai-engineering	multi-agent	LLM apps + RAG + multi-agent	4
8	ml-deploy	data, perf	Model deploy + data + performance	4
9	docs-publish	research	Documentation + reproducibility	4
10	plugin-forge	–	Claude Code extensions	4

Team 1: Feature Development¶

Build new features end-to-end with a design-first pipeline and automated review gate.

Agents¶

Role	Agent	Suite	Responsibility
architect	`feature-dev:code-architect`	feature-dev	Analyze codebase, produce implementation blueprint
builder	`dev-suite:app-developer`	dev-suite	Implement frontend components
backend	`dev-suite:software-architect`	dev-suite	Implement backend services and APIs
reviewer	`pr-review-toolkit:code-reviewer`	pr-review-toolkit	Review all changes (read-only)

Workflow¶

architect analyzes the codebase and produces an implementation blueprint for approval. Then builder (frontend) and backend work in parallel following the blueprint. Finally reviewer checks all changes for adherence to the blueprint and best practices.

Placeholders¶

FEATURE_NAME, FRONTEND_STACK, BACKEND_STACK, PROJECT

When to Use¶

Any feature build – full-stack, backend-only, or frontend-only – where you want a design-first approach with automated review.

Team 2: Debug¶

Consolidated debugging team covering all bug categories: general triage, GUI threading, numerical/JAX, schema drift, and production incidents.

Agents (by variant)¶

Variant	MODE	Agent 1	Agent 2	Agent 3	Agent 4
default	–	`feature-dev:code-explorer`	`dev-suite:debugger-pro`	`science-suite:python-pro`	(auto-selected specialist)
triage	`triage`	`feature-dev:code-explorer`	`dev-suite:debugger-pro`	–	–
gui	`gui`	`feature-dev:code-explorer`	`dev-suite:debugger-pro`	`science-suite:python-pro`	`dev-suite:sre-expert`
numerical	`numerical`	`feature-dev:code-explorer`	`dev-suite:debugger-pro`	`science-suite:python-pro`	`science-suite:jax-pro`
schema	`schema`	`feature-dev:code-explorer`	`dev-suite:debugger-pro`	`science-suite:python-pro`	`pr-review-toolkit:type-design-analyzer`
incident	`incident`	`dev-suite:debugger-pro`	`dev-suite:sre-expert`	`dev-suite:devops-architect`	–

Variant Details¶

Default (auto-detect): The explorer maps the architecture first, then debugger-pro and python-pro investigate in parallel. A fourth specialist is auto-selected based on symptoms: SRE for threading issues, jax-pro for numerical bugs, type-design-analyzer for schema drift.

Triage (--var MODE=triage): Lightweight 2-agent team for quick initial investigation (2-5 min). Explorer maps the execution path, then debugger-pro assesses severity (P0/P1/P2) and recommends whether to escalate to a full variant.

GUI (--var MODE=gui): Targets Qt threading bugs – signal safety, shiboken crashes, singleton races, event loop issues. SRE investigates GIL contention, QThread lifecycle, and cross-thread signal/slot safety. Python-pro checks attribute mismatches and Protocol compliance across abstraction boundaries.

Numerical (--var MODE=numerical): Targets JAX/numerical bugs – NaN gradients, ODE solver divergence, JIT tracing errors, shape mismatches. Jax-pro investigates XLA compilation failures, custom VJP correctness, non-JIT-safe operations, and host-device transfer overhead.

Schema (--var MODE=schema): Targets schema/type drift – incompatible data classes, field name mismatches, serialization errors. Type-design-analyzer rates types 1-5 and recommends canonical definitions. Note: do NOT run type-analyzer and quality-specialist simultaneously (they overlap on interface contract checking).

Incident (--var MODE=incident): 3-agent parallel-hypothesis investigation for production issues. Debugger examines application code, SRE checks observability data (metrics, logs, traces), and devops-architect investigates infrastructure. Agents share findings and challenge each other’s theories.

Workflow¶

All variants except incident: explorer first (architecture mapping) then remaining agents in parallel, then debugger-pro synthesizes findings into a prioritized fix list.

Incident variant: all 3 agents investigate simultaneously, then synthesize into a root cause report.

Cross-variant escalation: If root cause points to a different domain, switch variant (e.g., “if root cause is GUI -> --var MODE=gui”).

Placeholders¶

SYMPTOMS, AFFECTED_MODULES

Aliases¶

debug-triage -> debug --var MODE=triage, debug-gui -> debug --var MODE=gui, debug-numerical -> debug --var MODE=numerical, debug-schema -> debug --var MODE=schema, incident -> debug --var MODE=incident

Signals¶

Required: user-provided SYMPTOMS (all variants) or production incident context (incident variant). Debug team requires explicit symptoms – never auto-recommended without them.

Team 3: Quality Gate¶

Comprehensive code review and security audit with PR-specific analyzers and codebase-wide auditing.

Agents (by variant)¶

Variant	MODE	Agents
default	–	`pr-review-toolkit:silent-failure-hunter` + `pr-review-toolkit:pr-test-analyzer` + `pr-review-toolkit:type-design-analyzer` + `pr-review-toolkit:code-reviewer`
security	`security`	`dev-suite:software-architect` + `dev-suite:quality-specialist` + `dev-suite:sre-expert` + `dev-suite:debugger-pro`
full	`full`	Run default + security sequentially

Variant Details¶

Default: PR-focused review using the quality-gate-toolkit’s 4 specialized analyzers. Each reviewer works independently on the same diff: code-reviewer checks style/guidelines/bugs, silent-failure-hunter flags swallowed errors, pr-test-analyzer identifies coverage gaps, type-design-analyzer reviews type quality. Lead collects all findings sorted by severity.

Security (--var MODE=security): Codebase-wide security and architecture audit. Software-architect assesses design patterns, SOLID, and complexity. Quality-specialist scans for OWASP Top 10 vulnerabilities. SRE reviews operational security. Debugger-pro investigates runtime security concerns. Produces a prioritized remediation plan with CVSS severity.

Full (--var MODE=full): Runs both the default PR review pass and the security audit pass sequentially.

Placeholders¶

PR_OR_BRANCH (default), PROJECT_PATH (security)

Aliases¶

pr-review -> quality-gate, security -> quality-gate --var MODE=security

Signals¶

Required: git repo. Strong: open PR context. Auto-variant: security if missing security CI.

Team 4: API & Infrastructure¶

API design, cloud infrastructure, CI/CD, and configuration management.

Agents (by variant)¶

Variant	MODE	Agent 1	Agent 2	Agent 3	Agent 4
default (api)	–	`dev-suite:software-architect`	`dev-suite:app-developer`	`dev-suite:quality-specialist`	`dev-suite:sre-expert`
infra	`infra`	`dev-suite:devops-architect`	`dev-suite:automation-engineer`	`dev-suite:sre-expert`	–
config	`config`	`dev-suite:software-architect`	`dev-suite:automation-engineer`	`dev-suite:sre-expert`	`science-suite:python-pro`

Variant Details¶

Default (API): Full API design-build-test-observe pipeline. Architect designs the API spec (REST/GraphQL/gRPC), app-developer implements endpoints with auth and rate limiting, quality-specialist writes contract/integration/security tests, SRE adds observability. Workflow: architect defines spec -> implementer + tester in parallel -> SRE instruments.

Infra (--var MODE=infra): Cloud infrastructure and CI/CD from scratch. Devops-architect provisions IaC (Terraform/Pulumi) with zero-trust networking. Automation-engineer builds GitHub Actions pipelines for staged deployments. SRE sets up Prometheus, Grafana, OpenTelemetry, and alerting. Workflow: devops-architect first -> automation-engineer -> SRE.

Config (--var MODE=config): Configuration management, caching, and job scheduling. Architect designs config hierarchy and cache invalidation. Automation-engineer builds GitOps deployment pipelines. SRE monitors config propagation and cache hit rates. Python-pro implements typed config models and CLI tools.

Placeholders¶

SERVICE_NAME, API_PROTOCOL (api) | PROJECT_NAME, CLOUD_PROVIDER (infra) | PROJECT_NAME (config)

Aliases¶

api-design -> api-infra, infra-setup -> api-infra --var MODE=infra

Signals¶

Required (api): python | typescript | go | rust. Strong (api): src/api/, routes/, openapi.yaml. Required (infra): any. Strong (infra): terraform/, k8s/, Dockerfile.

Team 5: Scientific Computing¶

Consolidated team for all scientific computing: JAX/ML/DL pipelines, Bayesian inference, Julia SciML, nonlinear dynamics, MD simulation, scientific desktop apps, and paper reproduction.

Agents (by variant)¶

Variant	MODE	Agent 1	Agent 2	Agent 3	Agent 4
default (jax/ml)	–	`science-suite:jax-pro`	`science-suite:neural-network-master`	`science-suite:ml-expert`	`science-suite:research-expert`
bayesian	`bayesian`	`science-suite:jax-pro`	`science-suite:statistical-physicist`	`science-suite:ml-expert`	`science-suite:research-expert`
julia-sciml	`julia-sciml`	`science-suite:julia-pro`	`science-suite:simulation-expert`	`science-suite:jax-pro`	`science-suite:research-expert`
julia-ml	`julia-ml`	`science-suite:julia-ml-hpc`	`science-suite:neural-network-master`	`science-suite:ml-expert`	`science-suite:research-expert`
dynamics	`dynamics`	`science-suite:nonlinear-dynamics-expert`	`science-suite:jax-pro`	`science-suite:julia-pro`	`science-suite:research-expert`
md-sim	`md-sim`	`science-suite:simulation-expert`	`science-suite:jax-pro`	`science-suite:ml-expert`	`science-suite:research-expert`
desktop	`desktop`	`dev-suite:app-developer`	`science-suite:jax-pro`	`science-suite:python-pro`	`science-suite:research-expert`
reproduce	`reproduce`	`science-suite:research-expert`	`science-suite:python-pro`	`science-suite:jax-pro`	`science-suite:ml-expert`

Variant Details¶

Default (JAX/ML/DL): Build ML and deep learning pipelines with JAX. Jax-pro implements JIT-compiled kernels with vmap/pmap. Neural-network-master designs architectures with gradient flow analysis. ML-expert handles experiment tracking (W&B/MLflow), hyperparameter optimization, and model versioning. Research-expert validates methodology and reproducibility. JAX-first: minimize host-device transfers, use interpax for interpolation.

Bayesian (--var MODE=bayesian): Rigorous Bayesian inference with NumPyro and MCMC diagnostics. Statistical-physicist implements NumPyro models with NUTS sampler, warm-start from NLSQ. Jax-pro ensures convergence diagnostics: R-hat (<1.01), ESS (>400/chain), BFMI (>0.3). ML-expert runs model comparison (WAIC, LOO-CV via ArviZ). Mandatory ArviZ diagnostics and explicit seeds.

Julia SciML (--var MODE=julia-sciml): Julia’s SciML ecosystem (DifferentialEquations.jl, ModelingToolkit.jl). Julia-pro implements solvers with proper algorithm selection (Tsit5, TRBDF2, SOSRI for SDEs). Simulation-expert defines physical systems, conservation laws, and boundary conditions. Jax-pro handles Python-Julia interop for data exchange. Research-expert validates against analytical solutions.

Julia ML (--var MODE=julia-ml): Julia ML/DL/HPC with Lux.jl, CUDA.jl, MPI.jl. Julia-ml-hpc implements models with explicit parameter management and distributed training. Neural-network-master designs AD-friendly architectures. ML-expert sets up experiment tracking and benchmarks. Research-expert validates reproducibility.

Dynamics (--var MODE=dynamics): Bifurcation analysis, chaos, coupled oscillators, and equation discovery. Nonlinear-dynamics-expert classifies the system and designs the analysis protocol (phase portrait, Lyapunov exponents, SINDy/UDE). Jax-pro implements GPU-accelerated parameter sweeps. Julia-pro implements analysis via DynamicalSystems.jl and ChaosTools.jl. Research-expert validates against published benchmarks.

MD Simulation (--var MODE=md-sim): Molecular dynamics and ML force fields. Simulation-expert designs the simulation protocol: force field selection, ensemble settings, equilibration, and for ML workflows, DFT training data curation. Jax-pro implements JAX-MD kernels, neighbor lists, and enhanced sampling. ML-expert handles training loops with force matching loss. Research-expert validates (energy MAE, phonon dispersion, elastic constants). Force field validation before production runs.

Desktop (--var MODE=desktop): PyQt/PySide6 scientific desktop applications with JAX backends. App-developer builds the GUI with docking panels, PyQtGraph plots, and light/dark theming. Jax-pro implements the computation backend as a clean API (GUI never imports JAX directly). Python-pro wires GUI to backend: worker threads, signal/slot, config management, packaging. Research-expert validates numerical outputs.

Reproduce (--var MODE=reproduce): Research paper reproduction. Research-expert leads: decomposes the paper into implementable components, validates methodology, and designs the reproduction plan. Python-pro handles systems infrastructure and packaging. Jax-pro implements numerical kernels. ML-expert sets up experiment tracking and evaluation metrics. Goal: uv sync && uv run reproduce-all.

Auto-Variant Selection¶

When no MODE is specified and the recommender runs, signal detection determines the variant:

numpyro/pymc + arviz -> bayesian
julia + DifferentialEquations/ModelingToolkit -> julia-sciml
julia + Lux/Flux/MLJ + CUDA -> julia-ml
diffrax + DynamicalSystems/BifurcationKit -> dynamics
jax-md/openmm + trajectories -> md-sim
PyQt6/PySide6 + jax/numpy -> desktop
arxiv IDs in README -> reproduce
otherwise -> default

Placeholders¶

Aliases¶

bayesian -> sci-compute --var MODE=bayesian, julia-sciml -> sci-compute --var MODE=julia-sciml, julia-ml -> sci-compute --var MODE=julia-ml, nonlinear-dynamics -> sci-compute --var MODE=dynamics, md-simulation -> sci-compute --var MODE=md-sim, paper-implement -> sci-compute --var MODE=reproduce, sci-desktop -> sci-compute --var MODE=desktop

Signals¶

Required: python + (jax | equinox | optax) OR julia + (DifferentialEquations | Lux | Flux). Strong: experiments/, notebooks/, interpax, arviz, numpyro, DynamicalSystems, PyQt6, PySide6. Counter: react/next dominant (blocks science recommendation).

Team 6: Modernize¶

Migrate a legacy codebase to modern architecture using the Strangler Fig pattern.

Agents¶

Role	Agent	Suite	Responsibility
legacy-analyst	`dev-suite:software-architect`	dev-suite	Map legacy architecture, identify strangler boundaries, design target architecture with ADRs
migration-engineer	`dev-suite:systems-engineer`	dev-suite	Execute module-by-module migration with adapter layers for backward compatibility
quality-gate	`dev-suite:quality-specialist`	dev-suite	Write characterization tests BEFORE migration, run continuously to catch regressions
test-engineer	`dev-suite:debugger-pro`	dev-suite	Build migration test harness, validate feature parity

Workflow¶

legacy-analyst maps the existing codebase and designs the target architecture. quality-gate writes characterization tests for existing behavior. Then migration-engineer migrates module by module (characterization tests must pass before each module). test-engineer validates feature parity throughout.

Critical rule: QA must have characterization tests passing before migration-engineer begins each module.

Placeholders¶

LEGACY_SYSTEM, OLD_STACK, NEW_STACK

When to Use¶

Legacy migration, technology modernization, or major refactoring where the existing system must remain operational during transition.

Team 7: AI Engineering¶

Build production AI applications – RAG systems, LLM-powered apps, multi-agent orchestration, and prompt R&D.

Agents (by variant)¶

Variant	MODE	Agent 1	Agent 2	Agent 3	Agent 4
default (llm-app)	–	`science-suite:sci-workflow-engineer`	`agent-core:context-specialist`	`dev-suite:software-architect`	`science-suite:python-pro`
multi-agent	`multi-agent`	`agent-core:orchestrator`	`agent-core:reasoning-engine`	`agent-core:context-specialist`	`science-suite:sci-workflow-engineer`

Variant Details¶

Default (LLM app): Build RAG systems, LLM-powered apps, and tool-use agents. Sci-workflow-engineer designs the core pipeline (ingestion, chunking, embedding, retrieval, LLM orchestration, prompt templates, evaluation). Context-specialist handles memory systems, token budget, prompt caching, and knowledge persistence. Software-architect builds streaming API endpoints, caching, and observability. Python-pro handles Python systems integration.

Multi-Agent (--var MODE=multi-agent): Build multi-agent orchestration systems with 2+ coordinated agents. Orchestrator designs the agent topology (hub-spoke, pipeline, blackboard), task decomposition, and coordination protocol. Reasoning-engine reviews agent prompts for chain-of-thought quality and error recovery. Context-specialist implements shared memory, context passing, and knowledge persistence. Sci-workflow-engineer builds the agent runtime with tool definitions, LLM pipeline design, and evaluation frameworks.

Placeholders¶

USE_CASE

Aliases¶

llm-app -> ai-engineering, multi-agent -> ai-engineering --var MODE=multi-agent

Signals¶

Required: python + llm-libs. Strong: prompts/, rag/, vector DB. Auto-variant: multi-agent if agents/ + tools/ + langgraph.

Team 8: ML Deploy¶

Model deployment, data pipeline engineering, and performance optimization.

Agents (by variant)¶

Variant	MODE	Agent 1	Agent 2	Agent 3	Agent 4
default (deploy)	–	`science-suite:ml-expert`	`dev-suite:devops-architect`	`dev-suite:sre-expert`	`science-suite:jax-pro`
data	`data`	`science-suite:ml-expert`	`science-suite:python-pro`	`dev-suite:automation-engineer`	`science-suite:research-expert`
perf	`perf`	`dev-suite:debugger-pro`	`science-suite:python-pro`	`science-suite:jax-pro`	`dev-suite:systems-engineer`

Variant Details¶

Default (deploy): Deploy ML models to production. ML-expert handles model export (ONNX/SavedModel, quantization), model cards, and validation datasets. Devops-architect builds serving infrastructure (FastAPI/TorchServe/Triton), container packaging, autoscaling, and canary deployments. SRE sets up prediction drift detection, latency SLOs, and automated rollback. Jax-pro optimizes inference latency (XLA AOT, batch scheduling, model sharding).

Data (--var MODE=data): ETL pipelines, feature stores, and MLOps data infrastructure. ML-expert architects the ETL/ELT pipeline with schema validation (pandera) and incremental processing. Python-pro implements the feature store with online/offline serving and drift detection. Automation-engineer sets up orchestration (Airflow/Dagster) and data lineage. Research-expert implements data quality checks (Great Expectations) and anomaly detection. Key constraint: all transformations must be idempotent.

Perf (--var MODE=perf): CPU/GPU profiling and performance optimization. Debugger-pro investigates algorithmic bottlenecks, GIL contention, and I/O issues. Python-pro applies Cython/mypyc compilation, asyncio, and Rust extensions via PyO3. Jax-pro converts sequential loops to vmap, optimizes XLA compilation, and minimizes host-device transfers. Systems-engineer profiles CPU/memory/cache with perf, flamegraphs, and tracemalloc. Protocol: profile -> identify top 3 bottlenecks -> optimize one at a time -> re-profile.

Placeholders¶

MODEL_TYPE, SERVING_FRAMEWORK (deploy) | DATA_SOURCE, ML_TARGET (data) | TARGET_CODE, SPEEDUP_TARGET (perf)

Aliases¶

data-pipeline -> ml-deploy --var MODE=data, perf-optimize -> ml-deploy --var MODE=perf

Signals¶

Required: python + ml-libs. Strong: models/, serving/, deploy/. Auto-variant: data if dags/ + airflow; perf if benchmarks/ + profiling/.

Team 9: Docs & Publishing¶

Documentation overhaul and reproducible research infrastructure.

Agents (by variant)¶

Variant	MODE	Agent 1	Agent 2	Agent 3	Agent 4
default (docs)	–	`dev-suite:documentation-expert`	`dev-suite:software-architect`	`science-suite:research-expert`	`science-suite:python-pro`
research	`research`	`science-suite:research-expert`	`agent-core:context-specialist`	`science-suite:python-pro`	`dev-suite:automation-engineer`

Variant Details¶

Default (docs): Comprehensive documentation overhaul. Documentation-expert designs the information architecture following Diataxis (tutorials, how-tos, reference, explanation) and sets up Sphinx/MkDocs. Software-architect reviews technical accuracy by cross-referencing source code. Research-expert creates interactive tutorials, Jupyter notebooks, and Sphinx gallery examples. Python-pro structures the project as an installable package with proper CI. Goal: every public API must have docstring + reference page + example.

Research (--var MODE=research): Reproducible research infrastructure bridging science-suite and agent-core. Research-expert defines reproducibility requirements: experiment tracking, artifact versioning, data provenance. Context-specialist implements research knowledge graphs, paper reference management, and cross-project context sharing. Python-pro builds experiment runners, artifact storage (HDF5/Arrow), and CLI tools. Automation-engineer wires automated experiment scheduling, notebook execution, and reproducibility CI.

Placeholders¶

PROJECT_NAME (docs) | PROJECT_NAME, RESEARCH_GOAL (research)

Signals¶

Required: docs dir present. Strong: tutorials/, sphinx-gallery. Auto-variant: research if experiments/ + notebooks/ + references.bib.

Team 10: Plugin Forge¶

Build Claude Code extensions – plugins, hooks, agents, commands, skills, and SDK integrations.

Agents¶

Role	Agent	Suite	Responsibility
creator	`plugin-dev:agent-creator`	plugin-dev	Generate plugin structure: manifest, agents, commands, skills
hook-designer	`hookify:conversation-analyzer`	hookify	Analyze conversation patterns, design PreToolUse/SessionStart hooks
quality	`dev-suite:quality-specialist`	dev-suite	Write tests, set up CI for metadata validation and context budget
validator	`plugin-dev:plugin-validator`	plugin-dev	Validate complete plugin structure (read-only)

Workflow¶

creator + hook-designer work in parallel to generate plugin components and hook rules. Then quality writes tests and CI workflows. Finally validator checks the complete plugin structure: manifest schema, file references, frontmatter, and context budget.

Placeholders¶

PLUGIN_NAME, PLUGIN_DESCRIPTION

When to Use¶

Building any Claude Code extension: new plugins, custom hooks, agent definitions, slash commands, or skill files.

Long-Running Workflow Protocol¶

All teams follow this protocol for multi-session work, based on Anthropic’s Effective harnesses for long-running agents:

Session Init – First agent reads PROGRESS.md + recent git log. If no progress file exists, create one from the task prompt.
Task Tracking – Maintain PROGRESS.md as a structured JSON checklist. Each task maps to one agent’s deliverable.
Incremental Progress – Complete one task fully before starting the next. No parallel edits to the same file.
Clean State – Git commit after each completed task with descriptive message. Update progress file before commit.
Session Resume – On resume, read progress + git log + git diff. Skip completed tasks.
Verification – Run team-appropriate verification after each task (tests for dev teams, numerical validation for science teams).
QA Gate – Designated reviewer agent runs last, checks all completed tasks against the original spec.

Team-Specific Verification¶

Team	Env Check	Verification
feature-dev	Tests pass, linter clean	Test suite + manual feature test
debug	Symptoms reproduced	Original failure no longer triggers
quality-gate	PR branch checked out	All review comments addressable
api-infra	API server starts / terraform init	Contract tests / `terraform plan`
sci-compute	JAX/Julia/GPU detected	Numerical validation + convergence
modernize	Legacy system accessible	Feature parity tests
ai-engineering	API keys valid, MCP reachable	E2E agent execution
ml-deploy	Model loadable, infra available	Inference latency within SLO
docs-publish	Sphinx/MkDocs builds	No broken links, coverage > threshold
plugin-forge	Plugin structure valid	`metadata_validator.py` passes

Quality Gate Enhancers¶

Any team can be enhanced by adding official plugin agents as quality gates. Append an enhancer to any team’s configuration for automated review after implementation.

Enhancer	Agent Type	Best With	What It Catches
Code Review	`pr-review-toolkit:code-reviewer`	feature-dev, api-infra, modernize	Style, bugs, guidelines
Silent Failures	`pr-review-toolkit:silent-failure-hunter`	debug, api-infra:infra, docs-publish	Swallowed errors
Test Gaps	`pr-review-toolkit:pr-test-analyzer`	quality-gate, modernize, api-infra	Missing test coverage
Type Quality	`pr-review-toolkit:type-design-analyzer`	ml-deploy:data, docs-publish, sci-compute	Weak type invariants
Code Simplicity	`code-simplifier:code-simplifier`	modernize, ml-deploy:data, quality-gate	Unnecessary complexity
Plan Adherence	`superpowers:code-reviewer`	feature-dev, modernize, ml-deploy:perf	Drift from plan

To add an enhancer, append to any team prompt:

Additionally, spawn a "reviewer" teammate
(pr-review-toolkit:code-reviewer) that reviews all changes after the
implementation teammates finish their work. This reviewer is read-only
and reports issues sorted by severity. The team should not be considered
done until the reviewer's critical issues are addressed.

Alias Table¶

All 20 aliases for backward compatibility with previous team names:

#	Alias	Resolves To
1	`pr-review`	`quality-gate`
2	`security`	`quality-gate --var MODE=security`
3	`api-design`	`api-infra`
4	`infra-setup`	`api-infra --var MODE=infra`
5	`bayesian`	`sci-compute --var MODE=bayesian`
6	`julia-sciml`	`sci-compute --var MODE=julia-sciml`
7	`julia-ml`	`sci-compute --var MODE=julia-ml`
8	`nonlinear-dynamics`	`sci-compute --var MODE=dynamics`
9	`md-simulation`	`sci-compute --var MODE=md-sim`
10	`paper-implement`	`sci-compute --var MODE=reproduce`
11	`sci-desktop`	`sci-compute --var MODE=desktop`
12	`incident`	`debug --var MODE=incident`
13	`debug-triage`	`debug --var MODE=triage`
14	`debug-gui`	`debug --var MODE=gui`
15	`debug-numerical`	`debug --var MODE=numerical`
16	`debug-schema`	`debug --var MODE=schema`
17	`llm-app`	`ai-engineering`
18	`multi-agent`	`ai-engineering --var MODE=multi-agent`
19	`data-pipeline`	`ml-deploy --var MODE=data`
20	`perf-optimize`	`ml-deploy --var MODE=perf`

Usage Tips¶

Replace placeholders ([BRACKETS]) with your project specifics before pasting
Start with quality-gate (default variant) if new to agent teams – read-only, low-risk
Use delegate mode (Shift+Tab) to prevent the lead from implementing tasks itself
Monitor progress with Shift+Up/Down (in-process) or click panes (tmux)
Ctrl+T toggles the shared task list view
Prefer Sonnet for most teammates (cost-effective); use Opus for architecture/design decisions
Avoid file conflicts – ensure each teammate owns distinct directories
Use variants (--var MODE=x) to specialize a team without remembering separate team names
Use aliases when you remember the old name – /team-assemble bayesian resolves to sci-compute --var MODE=bayesian automatically
Default variants (no MODE) cover 80% of use cases – variants are optional specializations

References¶

Official Agent Teams Documentation
Claude Code Subagents
Claude Code Agent Teams Blog
Integration Map – Suite dependencies, MCP server roles, and skill coverage
Glossary – Key terms including hub skills, sub-skills, and routing trees