A Team — A Complete Engineering Team in One Folder v1.4.1

The pain: AI coding sessions can lose context, skip reviews, and claim progress without verification.

A complete engineering team in one folder. A Team packages 26 specialist agents, 20 skills, a lead orchestrator, and quality gates around a shared file-based workflow. Designed for Claude Code, Codex CLI, Cursor, OpenCode, and GitHub Copilot CLI — with different levels of hook support.

Not a marketplace of agents you configure. A structured starting point for your own projects.

Born from the community. A Team was built by studying, using, and needing to personalise several excellent open-source agent projects. The architecture combines the best patterns from each into a single, portable baseline. See Acknowledgments for the projects that made this possible.

→ Visual overview & live demo

Illustrative first session (expected workflow, not a recorded terminal capture):

/orchestrate init      → reads INIT.md; creates .agent-sync/TEAM.md and ROUTING.md
/orchestrate morning   → reads TASKS.md; proposes up to 3 tasks; pauses for approval

Getting started · Full documentation**

Domain packs — install any alongside A Team:

• builder-ai — LLM engineering quality (evals, RAG, prompt versioning, safety)
• builder-design — AI UI design (states, streaming, accessibility, tokens)
• builder-product — Product quality gates (PRD, metrics, research synthesis, AI validation)
• builder-growth — Growth & messaging (positioning, copy, experiments, retention)

What It Does

A Team turns any AI coding assistant into a structured, self-enforcing engineering team. Instead of one general-purpose model trying to do everything, you get:

• 26 specialist agents, each with a defined scope, model tier, and tool set
• 20 workflow skills that gate what can happen and when
• A lead orchestrator that manages daily task flow, dispatch, and state
• Quality-gate instructions and host-specific hooks (automatic enforcement varies by CLI)
• A pipeline auditor that verifies agents actually ran required checks — not just claimed they did

The infrastructure is stateless by design. Every agent derives its context from files, not memory. Sessions can be interrupted and resumed without drift.

Installation

Pick a method below. All copy the shared infrastructure plus platform-specific files. Copying plugin files is not the same as activating a CLI plugin; follow platform activation.

Option A — One-liner (recommended)

Mac / Linux / WSL:

bash <(curl -fsSL https://raw.githubusercontent.com/RBraga01/a-team/main/install.sh)

Windows PowerShell:

irm https://raw.githubusercontent.com/RBraga01/a-team/main/install.ps1 | iex

To install into a specific directory, pass the path as an argument:

bash <(curl -fsSL https://raw.githubusercontent.com/RBraga01/a-team/main/install.sh) /path/to/project

Option B — GitHub CLI

gh repo clone RBraga01/a-team -- --depth 1
cp -r a-team/.claude a-team/.claude-plugin a-team/.codex-plugin a-team/.cursor-plugin a-team/.copilot-plugin a-team/.opencode a-team/skills a-team/hooks a-team/templates a-team/scripts a-team/assets your-project/
cp -n a-team/AGENTS.md a-team/CLAUDE.md a-team/plugin.json your-project/
cp -n a-team/INIT_TEMPLATE.md your-project/INIT.md
rm -rf a-team

Option C — Git (no GitHub CLI)

git clone --filter=blob:none --sparse --depth 1 \
  https://github.com/RBraga01/a-team.git
cd a-team
git sparse-checkout set .claude .claude-plugin .codex-plugin .cursor-plugin .copilot-plugin .opencode skills hooks templates scripts assets
cp -r .claude .claude-plugin .codex-plugin .cursor-plugin .copilot-plugin .opencode skills hooks templates scripts assets ../your-project/
cp -n AGENTS.md CLAUDE.md plugin.json ../your-project/
cp -n INIT_TEMPLATE.md ../your-project/INIT.md
cd .. && rm -rf a-team

Windows (PowerShell equivalent):

git clone --filter=blob:none --sparse --depth 1 `
  https://github.com/RBraga01/a-team.git
cd a-team
git sparse-checkout set .claude .claude-plugin .codex-plugin .cursor-plugin .copilot-plugin .opencode skills hooks templates scripts assets
Copy-Item -Recurse .claude,.claude-plugin,.codex-plugin,.cursor-plugin,.copilot-plugin,.opencode,skills,hooks,templates,scripts,assets ..\your-project\
foreach ($f in 'AGENTS.md','CLAUDE.md','plugin.json','INIT_TEMPLATE.md') {
  $target = if ($f -eq 'INIT_TEMPLATE.md') { 'INIT.md' } else { $f }
  if (-not (Test-Path "..\\your-project\\$target")) { Copy-Item $f "..\\your-project\\$target" }
}
cd .. ; Remove-Item a-team -Recurse -Force

Option D — Download ZIP (no git required)

1. Go to github.com/RBraga01/a-team
2. Click Code → Download ZIP
3. Extract and copy .claude/, .claude-plugin/, .codex-plugin/, .cursor-plugin/, .copilot-plugin/, .opencode/, skills/, hooks/, templates/, scripts/, assets/ into your project root
4. Copy AGENTS.md, CLAUDE.md and root plugin.json only when they do not already exist; otherwise review and merge instructions manually. Copy INIT_TEMPLATE.md as INIT.md when absent.

Adding A Team to an Existing Project

If the project is already in progress, use cp -rn (no-clobber) when copying the folders so your existing files are not overwritten:

cp -rn a-team/.claude a-team/.claude-plugin a-team/.codex-plugin a-team/.cursor-plugin a-team/.copilot-plugin a-team/.opencode a-team/skills a-team/hooks a-team/templates a-team/scripts a-team/assets ./
cp -n a-team/AGENTS.md a-team/CLAUDE.md a-team/plugin.json ./
cp -n a-team/INIT_TEMPLATE.md ./INIT.md

Then fill out INIT.md to describe what already exists — languages, frameworks, current test coverage, known technical debt. The orchestrator uses this to prune irrelevant agents; accuracy here matters more than on a greenfield project.

After running /orchestrate init, review .agent-sync/TEAM.md before doing any work. Restore any agent that was incorrectly pruned. Start the first session with /orchestrate morning to let the orchestrator read the repo state before touching anything.

Note: For existing projects, Bash and PowerShell installers now merge missing files into existing folders without overwriting conflicts. Existing .claude/settings.json, CLAUDE.md and AGENTS.md are preserved — merge A Team policies and permissions manually after installation.

Quick Start

After installing, three steps to get the full team operational:

1. Fill out INIT.md

Open INIT.md and tick the checkboxes for your project:

• Primary languages (Go, Python, Kotlin, Swift, etc.)
• Tech stack (database, infra, CI/CD)
• Compliance scope (GDPR, PCI-DSS, etc.)
• Which AI platforms are active (Claude Code, Codex, Cursor, OpenCode, GitHub Copilot CLI)

Takes about 5 minutes.

2. Initialize the team

/orchestrate init

The orchestrator reads INIT.md, prunes irrelevant agents and skills, and generates:

• .agent-sync/TEAM.md — permanent record of the active roster
• .agent-sync/ROUTING.md — task routing table + file claims table

3. Start working

On Claude Code, the configured SessionStart hook loads using-a-team after the project is trusted. Other platforms require their own plugin activation and hook verification.

Tip: Run /orchestrate morning to propose today's tasks. Automatic hooks depend on the selected CLI and must be verified in that host.

Folder Layout

A Team/
├── README.md                  ← This file
├── CLAUDE.md                  ← Project overview loaded by Claude Code
├── AGENTS.md                  ← Agent roster & command reference
├── plugin.json                ← Portable Codex/Agent Plugins manifest
├── INIT_TEMPLATE.md           ← Template for project-specific init doc
├── AGENTS.md                  ← Project-level agent instructions (non-overwriting copy)
├── CLAUDE.md                  ← Project-level Claude instructions (non-overwriting copy)
│
├── .claude/
│   ├── settings.json          ← Permissions, hooks, worktree config
│   ├── agents/                ← 26 agent profiles (name, model, tools, instructions)
│   ├── commands/              ← Slash commands (/orchestrate, /plan, /quality-gate, …)
│   └── rules/                 ← Coding and workflow standards loaded by all agents
│
├── skills/                    ← 20 workflow skill modules (see docs/catalog.md)
│
├── hooks/
│   └── session-start.md       ← Injected at every session start
│
├── .claude-plugin/            ← Claude plugin/marketplace manifest
├── .cursor-plugin/            ← Cursor IDE integration
├── .codex-plugin/             ← Codex CLI integration
├── .copilot-plugin/           ← GitHub Copilot CLI integration
├── .opencode/                 ← OpenCode integration
├── scripts/                   ← Enforcement runtime and utilities
├── assets/                    ← Project branding
│
└── tests/                     ← Harness test suite for A Team itself

How the Team Works

1. Declare the project stack and boundaries in INIT.md.
2. /orchestrate init selects a roster and writes shared state to .agent-sync/.
3. /orchestrate morning proposes work from TASKS.md, then stops for human approval.
4. Skills define checks during implementation; reviews and the pipeline audit run before merge.

Detailed lifecycle, file claims, audit and coding standards.

Agent Roster (26)

10 core engineering agents, 8 language/platform specialists, and 8 operational/domain agents. Includes the lead orchestrator and typescript-reviewer. Complete roster.

Skill Library (20)

7 hard gates and 13 workflow/meta skills. api-contract-first and data-migration are hard gates. Complete library.

Mandatory Checks

Design before features, tests before implementation, root cause before fixes, contracts before endpoints, rollback planning before migrations, verification before completion, and human approval before merges. Full trigger map.

Multi-CLI Integration

A Team distributes definitions for five tools. Shared state in .agent-sync/ is portable once the CLIs load the definitions, but manifest presence alone does not guarantee plugin activation or hook parity. See platform activation.

What each platform loads

Copilot uses a separate legacy plugin installed from .copilot-plugin/. Whether its sibling component paths remain available after installation has not been verified; do not assume those hooks are active.

Running multiple CLIs on the same project

All CLIs share .agent-sync/ (DAILY.md, ROUTING.md, TEAM.md, results/). This means:

• The orchestrator's state is visible regardless of which CLI triggered it.
• File Claims are written once and honoured by any CLI reading ROUTING.md.
• Hooks are not propagated across platforms: each host needs its own configuration and activation; seeing a hook declaration does not prove that it has executed.

Platform-specific behaviour

Claude Code is the primary platform. It has the full hook system (SessionStart, PostToolUse), slash commands, and native sub-agent dispatch via the Agent tool.

Codex CLI has a portable root plugin.json, package-root skills, and a SessionStart hook declaration. It does not declare native specialist agents or slash commands in its plugin manifest. Validate runtime loading in Codex before relying on the gate.

Cursor declares project-root paths for agents, skills, rules and a session-start hook. It must be installed/activated as a Cursor Plugin. A Team does not currently package dedicated Cursor commands.

OpenCode receives A Team's command aliases in .opencode/commands/. This distribution does not bundle OpenCode-native agent or hook definitions; this is not a limitation of the OpenCode platform itself.

GitHub Copilot CLI has a legacy manifest declaring agents, skills and four hook events. Its installation command is valid, but package-relative component loading and enforcement parity have not been demonstrated on a real Copilot CLI session.

Install:

copilot plugin install RBraga01/a-team:.copilot-plugin

Command Reference

/orchestrate init       Read INIT.md, prune team, generate TEAM.md + ROUTING.md
/orchestrate morning    Plan today's tasks (requires human approval before dispatch)
/orchestrate tick       Process completed task results, dispatch unblocked tasks
/orchestrate report     End-of-day telemetry

/plan                   Create implementation plan
/feature                Full feature workflow: brainstorm → plan → implement → review
/code-review            Review staged/recent changes
/security-review        Security audit
/debug                  Systematic root-cause debugging
/build-fix              Fix build errors (minimal diffs only)
/e2e                    Run end-to-end test suite
/refactor               Find and remove dead code
/quality-gate           Full pre-merge check (code + security + audit)

Acknowledgments

A Team was built by studying the architecture and workflow patterns of the following open-source projects. No code or prompt text was copied verbatim — only concepts, patterns, and structural ideas were adapted and re-implemented from scratch.

License

MIT — see LICENSE. You are free to use, modify, and distribute A Team in any project, commercial or otherwise, as long as the copyright notice is retained.

Adding a New Agent

1. Create .claude/agents/<name>.md with the frontmatter (name, description, allowedTools, model) and instructions.
2. Add the agent to .agent-sync/TEAM.md (active roster).
3. Add a routing rule in .agent-sync/ROUTING.md.
4. Add the trigger condition to skills/using-a-team/SKILL.md.
5. Add a session-start check to hooks/session-start.md if the agent has a mandatory trigger.

Adding a New Skill

Use the /writing-skills meta-skill. It walks through spec, TDD, and validation of the new skill before it is added to the library. After creation, register the trigger in using-a-team/SKILL.md.