New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Agent Teams

by alinaqi in alinaqi/maggy

Claude Code Agent Teams - default team-based development with strict TDD pipeline enforcement

MITAuto-check: notesTesting & QA

Install Agent Teams

skills CLI
$ npx skills add alinaqi/maggy --skill agent-teams -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install alinaqi/maggy agent-teams --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/alinaqi/maggy.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/agent-teams .claude/skills/agent-teams && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
agent-teams
GitHub stars
707
Token cost
~5k tokens
SKILL.md length
1,331 words
Files
7
Skills in repo
71
Repo updated
First seen
Licence
MIT

At a glance

Claude Code Agent Teams - default team-based development with strict TDD pipeline enforcement

  • Works in 9 steps: Write Spec → Write Tests (RED Phase) → Wait for RED Verification → …
  • Tasks that involve Test-driven development
  • SKILL.md covers Core Principle, Default Agent Roster, Team Lead Responsibilities and Feature Agent Workflow…, plus 7 more sections
  • Calls git and gh

What it does

Agent Teams is an agent skill from alinaqi/maggy. Claude Code Agent Teams - default team-based development with strict TDD pipeline enforcement

Its SKILL.md is about 5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 7 other files (for example `agents/code-review.md`, `agents/feature.md` and `agents/merger.md`).

It sits in Testing & QA, covering Test-driven development. The repository describes itself as: What started as an opinionated Claude Code setup kit is now an autonomous AI engineering command center. The licence is MIT.

When your agent uses it

  • Tasks that involve Test-driven development

Example prompts

  • “/agent-teams”

Workflow steps

9 steps, taken from the step headings in SKILL.md.

  1. Write Spec
  2. Write Tests (RED Phase)
  3. Wait for RED Verification
  4. Implement (GREEN Phase)
  5. Wait for GREEN Verification
  6. Validate
  7. Wait for Code Review
  8. Wait for Security Scan
  9. Wait for Branch + PR

What it can do on your machine

Read from SKILL.md and the folder at commit 72a456e. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • git
    • gh

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use git and gh, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Agent Teams loads about 5k tokens when it runs. Until then it costs about 26 tokens; SKILL.md has 1,331 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~26
When it runs · the whole SKILL.md, loaded when a task matches
~5k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NoteMentions a .env fileSKILL.md:76
    │                   Dependency audit, .env validation               │

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from alinaqi/maggy at commit 72a456e, republished under its MIT licence (© alinaqi). 1,331 words, ~4,995 tokens.

Download SKILL.mdSave it as .claude/skills/agent-teams/SKILL.md (or your agent's skills folder). This skill also uses 6 other files; get the full folder from GitHub.
name
agent-teams
description
Claude Code Agent Teams - default team-based development with strict TDD pipeline enforcement
when-to-use
When spawning agent teams for parallel feature development with TDD pipeline
user-invocable
false
effort
high

Agent Teams Skill

Purpose: Every project initialized with Maggy runs as a coordinated team of AI agents. This is the default workflow, not optional. Teams enforce a strict TDD pipeline where no step can be skipped.

Setup: Agent definitions go in .claude/agents/ with proper frontmatter (name, description, model, tools, disallowedTools, maxTurns, effort). See agent files for the format.

Core Principle

Every feature follows an immutable pipeline enforced by task dependencies:

┌─────────────────────────────────────────────────────────────────┐
│  STRICT FEATURE PIPELINE (IMMUTABLE)                            │
│  ──────────────────────────────────────────────────────────────  │
│                                                                  │
│  1. SPEC        Write feature specification                      │
│       ↓         (Feature Agent)                                  │
│  2. REVIEW      Quality Agent reviews spec completeness          │
│       ↓         (Quality Agent)                                  │
│  3. TESTS       Write failing tests for all acceptance criteria  │
│       ↓         (Feature Agent)                                  │
│  4. RED VERIFY  Quality Agent confirms ALL tests FAIL            │
│       ↓         (Quality Agent)                                  │
│  5. IMPLEMENT   Write minimum code to pass tests                 │
│       ↓         (Feature Agent)                                  │
│  6. GREEN VERIFY Quality Agent confirms ALL tests PASS + coverage│
│       ↓         (Quality Agent)                                  │
│  7. VALIDATE    Lint + type check + full test suite              │
│       ↓         (Feature Agent)                                  │
│  8. CODE REVIEW Multi-engine review, block on Critical/High      │
│       ↓         (Code Review Agent)                              │
│  9. SECURITY    OWASP scan, secrets detection, dependency audit  │
│       ↓         (Security Agent)                                 │
│  10. BRANCH+PR  Create feature branch, stage files, create PR    │
│                 (Merger Agent)                                    │
│                                                                  │
│  No step can be skipped. Task dependencies enforce ordering.     │
│  Quality Agent verifies RED/GREEN transitions.                   │
│  Code Review + Security Agents gate the merge path.              │
│  Merger Agent handles branching and PR creation.                 │
└─────────────────────────────────────────────────────────────────┘

Default Agent Roster

Every project spawns 5 permanent agents + N feature agents:

┌─────────────────────────────────────────────────────────────────┐
│  DEFAULT TEAM ROSTER                                             │
│  ──────────────────────────────────────────────────────────────  │
│                                                                  │
│  PERMANENT AGENTS (always present)                               │
│  ─────────────────────────────────                               │
│  Team Lead        Orchestration, task breakdown, assignment      │
│                   Uses delegate mode - NEVER writes code         │
│                                                                  │
│  Quality Agent    TDD verification (RED/GREEN phases)            │
│                   Coverage gates (>= 80%)                        │
│                   Spec completeness review                       │
│                                                                  │
│  Security Agent   OWASP scanning, secrets detection              │
│                   Dependency audit, .env validation               │
│                   Blocks on Critical/High                        │
│                                                                  │
│  Code Review Agent  Multi-engine code review                     │
│                     Claude / Codex / Gemini / All                │
│                     Blocks on Critical/High                      │
│                                                                  │
│  Merger Agent     Creates feature branches                       │
│                   Stages feature-specific files only              │
│                   Creates PRs via gh CLI                          │
│                   NEVER merges - only creates PRs                │
│                                                                  │
│  DYNAMIC AGENTS (one per feature)                                │
│  ────────────────────────────────                                │
│  Feature Agent    Implements one feature end-to-end              │
│  (x N features)   Follows strict pipeline above                  │
│                   Uses Ralph loops for implementation             │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘
AgentRolePlan ModeCan Edit Code
team-leadOrchestration, task breakdown, assignmentNo (delegate mode)No
quality-agentTDD verification, coverage gatesYesNo (read-only)
security-agentOWASP scanning, secrets detectionYesNo (read-only)
review-agentMulti-engine code reviewYesNo (read-only)
merger-agentBranch creation, PR managementNoNo (git only)
feature-{name}Feature implementation (one per feature)NoYes

Team Lead Responsibilities

The Team Lead is the orchestrator. It NEVER writes code.

  1. Read _project_specs/features/*.md to identify all features
  2. Break each feature into the 10-task dependency chain (see below)
  3. Spawn one feature agent per feature
  4. Assign initial tasks (spec-writing) to feature agents
  5. Monitor TaskList continuously for progress and blockers
  6. Handle blocked tasks and reassignment
  7. Coordinate cross-feature dependencies
  8. Send shutdown_request to all agents when all PRs are created
  9. Clean up the team when done

Delegate mode is mandatory. The team lead uses only:

  • TeamCreate, TaskCreate, TaskUpdate, TaskList, TaskGet
  • SendMessage (message, broadcast, shutdown_request)
  • Read, Glob, Grep (for monitoring)

Feature Agent Workflow (MANDATORY)

Each feature agent MUST follow this exact sequence. Task dependencies enforce ordering - a feature agent cannot start step N+1 until step N is marked complete and verified.

Step 1: Write Spec
  • Create _project_specs/features/{feature-name}.md
  • Include: description, acceptance criteria, test cases table, dependencies
  • Follow the atomic TODO format from base.md skill
  • Mark task complete -> Quality Agent reviews
Step 2: Write Tests (RED Phase)
  • Write test files based on spec's test cases table
  • Tests MUST cover ALL acceptance criteria
  • Import modules that don't exist yet (they will fail)
  • Mark task complete -> Quality Agent verifies tests EXIST and FAIL
Step 3: Wait for RED Verification
  • Quality Agent runs tests and verifies ALL new tests fail
  • If any test passes without implementation -> rewrite tests
  • Quality Agent marks verification complete -> unlocks implementation
Step 4: Implement (GREEN Phase)
  • Write minimum code to make all tests pass
  • Follow simplicity rules from base.md (20 lines/function, 200 lines/file, 3 params)
  • Use Ralph loops (/ralph-loop) for iterative implementation
  • Run tests after implementation - ALL must pass
  • Mark task complete -> Quality Agent verifies tests pass
Step 5: Wait for GREEN Verification
  • Quality Agent runs full test suite and checks coverage
  • Coverage must be >= 80%
  • If tests fail or coverage insufficient -> fix and re-request
  • Quality Agent marks verification complete -> unlocks validation
Step 6: Validate
  • Run linter (ESLint / Ruff)
  • Run type checker (TypeScript / mypy)
  • Run full test suite with coverage
  • Fix any issues
  • Mark task complete -> unlocks code review
Step 7: Wait for Code Review
  • Code Review Agent runs /code-review on changed files
  • If Critical or High issues -> fix and re-request review
  • Code Review Agent marks complete -> unlocks security scan
Step 8: Wait for Security Scan
  • Security Agent runs security checks
  • If Critical or High issues -> fix and re-request scan
  • Security Agent marks complete -> unlocks merge
Step 9: Wait for Branch + PR
  • Merger Agent creates feature branch, stages files, creates PR
  • Feature is complete when PR is created

Task Dependency Chain Model

For each feature "X", the team lead creates these 10 tasks with strict ordering:

┌────────────────────────────────────────────────────────────────┐
│  TASK CHAIN FOR FEATURE "X"                                     │
│                                                                  │
│  Task 1:  X-spec                                                │
│           owner: feature-X                                       │
│           blockedBy: (none)                                      │
│           ↓                                                      │
│  Task 2:  X-spec-review                                         │
│           owner: quality-agent                                   │
│           blockedBy: X-spec                                      │
│           ↓                                                      │
│  Task 3:  X-tests                                               │
│           owner: feature-X                                       │
│           blockedBy: X-spec-review                               │
│           ↓                                                      │
│  Task 4:  X-tests-fail-verify                                   │
│           owner: quality-agent                                   │
│           blockedBy: X-tests                                     │
│           ↓                                                      │
│  Task 5:  X-implement                                           │
│           owner: feature-X                                       │
│           blockedBy: X-tests-fail-verify                         │
│           ↓                                                      │
│  Task 6:  X-tests-pass-verify                                   │
│           owner: quality-agent                                   │
│           blockedBy: X-implement                                 │
│           ↓                                                      │
│  Task 7:  X-validate                                            │
│           owner: feature-X                                       │
│           blockedBy: X-tests-pass-verify                         │
│           ↓                                                      │
│  Task 8:  X-code-review                                         │
│           owner: review-agent                                    │
│           blockedBy: X-validate                                  │
│           ↓                                                      │
│  Task 9:  X-security-scan                                       │
│           owner: security-agent                                  │
│           blockedBy: X-code-review                               │
│           ↓                                                      │
│  Task 10: X-branch-pr                                           │
│           owner: merger-agent                                    │
│           blockedBy: X-security-scan                             │
└────────────────────────────────────────────────────────────────┘
Parallel Feature Execution

Multiple features run their chains in parallel. Shared agents process tasks as they unblock:

Feature: auth         Feature: dashboard      Feature: payments
  auth-spec             dash-spec               pay-spec
  auth-spec-review      dash-spec-review        pay-spec-review
  auth-tests            dash-tests              pay-tests
  auth-fail-verify      dash-fail-verify        pay-fail-verify
  auth-implement        dash-implement          pay-implement
  auth-pass-verify      dash-pass-verify        pay-pass-verify
  auth-validate         dash-validate           pay-validate
  auth-code-review      dash-code-review        pay-code-review
  auth-security         dash-security           pay-security
  auth-branch-pr        dash-branch-pr          pay-branch-pr
       |                     |                       |
       v                     v                       v
   [All chains run simultaneously]
   [Quality Agent handles all verify tasks as they unblock]
   [Review Agent handles all review tasks as they unblock]
   [Security Agent handles all scan tasks as they unblock]
   [Merger Agent handles all branch-pr tasks as they unblock]

Inter-Agent Communication

Direct Messages (for targeted work)
Feature Agent -> Quality Agent:  "Tests written for auth, ready for RED verify"
Quality Agent -> Feature Agent:  "All 7 tests fail as expected. Proceed to implement"
Feature Agent -> Review Agent:   "Implementation complete, ready for code review"
Review Agent  -> Feature Agent:  "2 High issues found: [details]. Fix before proceeding"
Security Agent -> Merger Agent:  "Security scan passed for auth feature"
Merger Agent  -> Team Lead:      "PR #42 created for auth feature"
Task List (source of truth for state)
  • All agents check TaskList after completing work
  • Quality Agent claims verification tasks automatically
  • Review Agent claims code-review tasks automatically
  • Security Agent claims security-scan tasks automatically
  • Merger Agent claims branch-pr tasks automatically
Broadcast (rare - blocking issues only)
  • Team Lead -> All: "Blocking dependency found between auth and dashboard"
  • Security Agent -> All: "Critical vulnerability in shared dependency"

Feature Agent Spawning

The team lead spawns one feature agent per feature:

  1. Read _project_specs/features/*.md
  2. For each feature spec, spawn a feature agent:
    • name: feature-{feature-name}
    • Uses .claude/agents/feature.md definition
    • Spawn prompt includes the feature name and spec location
  3. Create the full 10-task dependency chain for that feature
  4. Assign the spec-writing task to the feature agent
Example

If project has 3 features: auth, dashboard, payments

  • Spawn: feature-auth, feature-dashboard, feature-payments
  • Create 30 tasks total (10 per feature)
  • Each feature agent starts with their spec task
  • All 3 work in parallel

Branch and PR Strategy

One branch per feature. One PR per feature.

Branch naming:  feature/{feature-name}
PR title:       feat({feature-name}): {short description}
PR body:        Generated from spec + test results + review + security results

The Merger Agent:

  1. git checkout main && git pull origin main
  2. git checkout -b feature/{feature-name}
  3. Stages ONLY files changed for this feature (never git add -A)
  4. Commits with descriptive message including verification results
  5. git push -u origin feature/{feature-name}
  6. gh pr create with full template including:
    • Summary from feature spec
    • Test results from quality verification
    • Code review summary from review agent
    • Security scan results from security agent
    • Checklist of all pipeline steps completed
Show full SKILL.md (489 more words)Show less

Quality Gates

Workflow Enforcement (via task dependencies)
  • Task dependencies make it structurally impossible to skip steps
  • A feature agent cannot see "implement" until quality agent completes "tests-fail-verify"
  • This is the primary enforcement mechanism
Cross-Agent Verification (trust but verify)
  • Quality agent independently runs tests (doesn't trust feature agent's report)
  • Security agent independently scans (doesn't trust review agent)
  • Merger agent verifies all predecessor tasks are complete before branching
Blocking Rules
  • Quality Agent: blocks if tests don't fail (RED) or don't pass (GREEN) or coverage < 80%
  • Code Review Agent: blocks on Critical or High severity issues
  • Security Agent: blocks on Critical or High severity findings
  • Merger Agent: refuses to branch if any predecessor task is incomplete

Integration with Existing Skills

Existing SkillHow Agent Teams Uses It
base.mdTDD workflow, atomic todos, simplicity rules - all agents follow
code-review.mdReview Agent executes /code-review per this skill
security.mdSecurity Agent follows OWASP patterns from this skill
session-management.mdEach agent maintains its own session state
iterative-development.mdFeature agents use Stop hook TDD loops for implementation
project-tooling.mdMerger Agent uses gh CLI for branches and PRs
team-coordination.mdSuperseded by agent-teams for automated coordination
icpg.mdTeam lead creates ReasonNodes. Feature agents query constraints/risk. Quality agent checks drift. PreToolUse hook injects context. Stop hook auto-records symbols.
code-graph.mdFeature agents use graph for symbol lookup alongside iCPG for intent context

Environment Setup

Required Setting
json
// settings.json or environment
{
  "env": {
    "agent teams (via .claude/agents/ definitions)": "1"
  }
}
Project Structure (created by /initialize-project)
.claude/
  agents/            # Agent definitions (from agent-teams skill)
    team-lead.md
    quality.md
    security.md
    code-review.md
    merger.md
    feature.md
  skills/
    agent-teams/     # This skill
      SKILL.md
      agents/        # Agent definition templates
    base/
    code-review/
    security/
    ...

Spawning the Team

Automatic (via /initialize-project)

After project setup completes, Phase 6 asks for features and spawns the team automatically.

Manual (via /spawn-team)

For existing projects: run /spawn-team to spawn the team from existing feature specs.

Container Isolation (Polyphony)

When Docker/OrbStack is available, feature agents run in Polyphony containers by default. The team lead and shared agents (quality, security, review, merger) still run natively — they only read and coordinate.

What changes with Polyphony
AspectWithout PolyphonyWith Polyphony
Feature agentsShared filesystemOwn container + git branch
File conflictsTeam lead must serializeImpossible (isolated clones)
Test executionShared, can interfereIndependent per container
Branch strategyMerger agent creates branchesEach container has its own branch
How it works
  1. /spawn-team detects Docker + polyphony CLI
  2. For each feature, runs polyphony spawn "$FEATURE" --type feature
  3. Polyphony creates a container with its own git clone + branch
  4. Agent CLI starts inside the container
  5. On completion, changes are on a dedicated branch ready for PR
Fallback

If Docker is not available, /spawn-team falls back to the native Agent tool (shared filesystem). A note is printed:

"Running without container isolation (Docker not found). Agents share the workspace."

Limitations

  • Experimental feature - Agent teams require the experimental env var
  • No nested teams - Teammates cannot spawn sub-teams
  • One team per session - Clean up before starting a new team
  • No session resumption - If session dies, re-run /spawn-team (tasks persist)
  • File conflicts - Features sharing files must be serialized by team lead (unless using Polyphony containers)
  • Token cost - Each agent is a separate Claude instance (5 + N instances)

© alinaqi, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 6 other files in skills/agent-teams of alinaqi/maggy.

  • SKILL.md
  • agents/code-review.md
  • agents/feature.md
  • agents/merger.md
  • agents/quality.md
  • agents/security.md
  • agents/team-lead.md

Open the folder on GitHubat commit 72a456e

Compare with similar skills

Agent Teams next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Agent Teams compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Agent Teams this skillalinaqi/maggy707—~5kAutomated safety check: NotesMIT
Testing Skills With Subagentsed3dai/ed3d-plugins2503 repos~3.5kAutomated safety check: PassNone
Feature Next Task Workflowmylukin/agent-foreman250—~927Automated safety check: NotesNone
Agent Task Backlog Initializermylukin/agent-foreman250—~681Automated safety check: NotesNone
Foreman VerifyVisionForge-OU/foreman443—~901Automated safety check: PassCustom licence
Superpowers Feature WorkflowSYZ-Coder/superpowers-openspec-team-skills196—~891Automated safety check: PassMIT

Similar skills

  • Testing Skills With Subagents

    ed3dai/ed3d-plugins

    A skill your agent uses when creating or editing skills, before deployment, to verify they work under pressure and resist rationalization - applies RED-GREEN-REFACTOR cycle to process documentation…

    250 GitHub starsUsed in 3 repos~3.5k tokens
    Testing & QAAuto-check passed

  • Feature Next Task Workflow

    mylukin/agent-foreman

    Enforces a strict next-implement-check-done cycle through the agent-foreman CLI so an agent works one backlog task at a time, with optional TDD gating.

    250 GitHub stars~927 tokensUpdated 8 mo ago
    Testing & QAAuto-check: notes

  • Agent Task Backlog Initializer

    mylukin/agent-foreman

    Builds a feature backlog, progress log, and optional strict test enforcement for agent-driven work with a single init command.

    250 GitHub stars~681 tokensUpdated 8 mo ago
    Testing & QAAuto-check: notes

  • Foreman Verify

    VisionForge-OU/foreman

    Headless self-verification gate a Foreman worker runs before it claims an issue is done.

    443 GitHub stars~901 tokensUpdated 3 mo ago
    Testing & QAAuto-check passed

  • Superpowers Feature Workflow

    SYZ-Coder/superpowers-openspec-team-skills

    A skill your agent uses when feature work needs the Superpowers stages before or during implementation: brainstorming, design confirmation, implementation planning, worktree setup, test-driven…

    196 GitHub stars~891 tokensUpdated 4 mo ago
    Testing & QAAuto-check passed

  • Nv Implement

    novuhq/novu

    Implement planned work by fanning out parallel subagents on isolated worktrees — TDD at pre-agreed seams, per-slice nv-park-and-review, merge back, full suite once at the end.

    40k GitHub stars~1.7k tokensUpdated today
    Testing & QAAuto-check passed

More from alinaqi/maggy

All 71 skills in this repo

  • Aeo Optimization

    alinaqi/maggy

    AI Engine Optimization - semantic triples, page templates, content clusters for AI citations

    707 GitHub stars~3.7k tokensUpdated 16 days ago
    Auto-check passed

  • AI Models

    alinaqi/maggy

    Latest AI models reference - Claude, OpenAI, Gemini, Eleven Labs, Replicate

    707 GitHub stars~4.1k tokensUpdated 16 days ago
    Auto-check passed

  • Android Java

    alinaqi/maggy

    Android Java development with MVVM, ViewBinding, and Espresso testing

    707 GitHub stars~3.9k tokensUpdated 16 days ago
    Auto-check: notes

  • Android Kotlin

    alinaqi/maggy

    Android Kotlin development with Coroutines, Jetpack Compose, Hilt, and MockK testing

    707 GitHub stars~3k tokensUpdated 16 days ago
    Auto-check passed

  • Autonomous Testing

    alinaqi/maggy

    AI-driven testing agent that auto-discovers, generates, executes, evaluates, and fixes tests for any project type

    707 GitHub stars~1.1k tokensUpdated 16 days ago
    Auto-check passed

  • AWS Aurora

    alinaqi/maggy

    AWS Aurora Serverless v2, RDS Proxy, Data API, connection pooling

    707 GitHub stars~3.9k tokensUpdated 16 days ago
    Auto-check passed

Categories

Questions about Agent Teams

What does Agent Teams do?

Claude Code Agent Teams - default team-based development with strict TDD pipeline enforcement. Agent Teams is an agent skill from alinaqi/maggy.

When should I use Agent Teams?

Agent Teams fits situations like: tasks that involve Test-driven development.

How do I install Agent Teams in Claude Code?

Run `npx skills add alinaqi/maggy --skill agent-teams -a claude-code`. Or copy the skill folder (skills/agent-teams in alinaqi/maggy) into .claude/skills/agent-teams in your project. Claude Code loads it when a task matches its description.

How do I install Agent Teams in Codex?

Run `npx skills add alinaqi/maggy --skill agent-teams -a codex`. Or copy the skill folder (skills/agent-teams in alinaqi/maggy) into .agents/skills/agent-teams in your project. Codex loads it when a task matches its description.

Can I use Agent Teams in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add alinaqi/maggy --skill agent-teams -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/agent-teams, .gemini/skills/agent-teams, .github/skills/agent-teams and .opencode/skills/agent-teams in your project.

What does Agent Teams need to run?

Going by SKILL.md and its folder, Agent Teams needs the command-line tools its instructions call (git and gh).

Does Agent Teams access the network?

SKILL.md contains no URLs. Its commands use git and gh, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Agent Teams safe to install?

Our automated static check of SKILL.md found notes only (mentions a .env file), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Agent Teams use?

Agent Teams is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Agent Teams use?

About 5k tokens (SKILL.md is roughly 20k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Agent Teams?

Skills that share tags, products or a category with Agent Teams: Testing Skills With Subagents (ed3dai/ed3d-plugins, 250 stars), Feature Next Task Workflow (mylukin/agent-foreman, 250 stars), Agent Task Backlog Initializer (mylukin/agent-foreman, 250 stars) and Foreman Verify (VisionForge-OU/foreman, 443 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Agent Teams?

alinaqi (a GitHub user) maintains it in alinaqi/maggy, which has 707 GitHub stars. The repository holds 71 skills in this directory. The repository was last updated on September 24, 2026.

Source: alinaqi/maggy on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.