Przejdź do treści
Biblioteka skilli
AI i agenci · Budowanie i kod

team-dev

/team-dev

Realizuje plan implementacji równolegle przez zespół agentów, z kierownikiem zespołu egzekwującym zgodność ze specyfikacją i przeglądy kodu.

Repozytorium
jig ↗
Licencja
MIT
Ostatnia zmiana repozytorium
27.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
4
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 27.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Realizuje plan implementacji równolegle przez zespół agentów, z kierownikiem zespołu egzekwującym zgodność ze specyfikacją i przeglądy kodu.

Oryginalny opis (EN)

Use when executing an implementation plan in parallel with agent teams and quality gates. Spawns implementer teammates in split panes, orchestrated by a team lead who enforces spec compliance and code quality reviews.

Jak działa

  1. When to Use
  2. Prerequisites
  3. The Process
  4. Prompt Templates
  5. Key Design Decisions
  6. Red Flags
  7. Integration
  8. Limitations
Sekcje z nagłówków SKILL.md, w oryginale · 204 linii, 1 264 słów
Podgląd SKILL.md
---
name: team-dev
description: >
  Use when executing an implementation plan in parallel with agent teams and quality gates.
  Spawns implementer teammates in split panes, orchestrated by a team lead who
  enforces spec compliance and code quality reviews.
tier: workflow
alwaysApply: false
---

# Team-Driven Development

Execute implementation plans by spawning implementer teammates that work in parallel, each in their own split pane. The team lead orchestrates a staggered review pipeline — as each implementer finishes, the lead dispatches spec compliance and code quality reviewer subagents. Quality gates are enforced: no task is complete until both reviews pass.

**Core principle:** Parallel implementation via agent teams + two-stage review gates = fast iteration with high quality.

## When to Use

```mermaid
flowchart TD
    A{Have implementation<br/>plan?} -->|No| B[Use spec +<br/>plan first]
    A -->|Yes| C{3+ independent<br/>tasks?}
    C -->|No| D[Use sdd<br/>sequential]
    C -->|Yes| E{Tasks touch mostly<br/>different files?}
    E -->|No| F[Use sdd<br/>sequential]
    E -->|Yes| G{Agent teams<br/>enabled?}
    G -->|No| H[Enable agent teams<br/>or use sdd]
    G -->|Yes| I[team-dev]
    style I fill:#e8f5e9
```

### Comparison

| | sdd | Parallel Agents | team-dev |
|---|---|---|---|
| **Execution** | Sequential, one task at a time | Parallel, fire-and-forget | Parallel, staggered pipeline |
| **Quality Gates** | Spec + quality review | None | Spec + quality review |
| **Visibility** | Single session | Background subagents | Split panes, interactive |
| **Feedback Loop** | Synchronous within session | None | Bidirectional via SendMessage |
| **Best For** | Sequential or coupled tasks | Quick parallel research | Independent tasks with quality needs |
| **Token Cost** | Lowest | Medium | Highest (persistent sessions) |

## Prerequisites

- **Agent teams enabled**: `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: "1"` in settings
- **tmux teammate mode**: `teammateMode: "tmux"` in `~/.claude/settings.json` (recommended for split panes)
- **Running inside tmux**: Launch via `tmux -CC` in iTerm2 or `tmux new -s claude` then `claude`
- **Implementation plan**: A numbered plan with tasks (from `plan`)

### Quick Setup

**1. Enable agent teams** — add to your project's `.claude/settings.json`:
```json
{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}
```

**2. Enable tmux teammate mode** — add to your user settings at `~/.claude/settings.json`:
```json
{
  "teammateMode": "tmux"
}
```

**3. Launch Claude inside tmux**:
```bash
# iTerm2 (recommended — gives you native iTerm2 tabs/panes)
tmux -CC

# Standard terminal
tmux new -s claude
```
Then run `claude` from inside the tmux session. Teammates appear as split panes automatically.

**4. Have an implementation plan** — use `plan` to generate one, or write one manually.

## The Process

```mermaid
flowchart TD
    read[1. Read plan<br/>Analyze dependencies + file overlap] --> count[2. Determine implementer count<br/>Bias toward 3]
    count --> create[3. TeamCreate + TaskCreate<br/>Set blockedBy relationships]
    create --> spawn[4. Spawn implementer teammates<br/>One per initial parallel task]
    spawn --> work[Implementer works<br/>Implement, test, self-review]
    work --> done[Implementer reports done]
    done --> spec[Lead dispatches<br/>spec reviewer subagent]
    spec --> spec_pass{Spec passes?}
    spec_pass -->|No| spec_fix[Send feedback<br/>Implementer fixes] -.-> spec
    spec_pass -->|Yes| quality[Lead dispatches<br/>swarm review - fast-pass]
    quality --> qual_pass{Quality passes?}
    qual_pass -->|No| qual_fix[Send feedback<br/>Implementer fixes] -.-> quality
    qual_pass -->|Yes| complete[Task complete]
    complete --> more{More unblocked tasks?}
    more -->|Yes| related{Related to<br/>implementer's work?}
    more -->|No| shutdown[Shut down implementer]
    related -->|Yes| reuse[Reuse implementer<br/>Send next task] --> work
    related -->|No| fresh[Shut down + spawn fresh] --> work
    shutdown -.->|when all done| all_done[All tasks complete]
    all_done --> integration[Final integration review]
    integration --> cleanup[Shutdown teammates<br/>TeamDelete]
    cleanup --> finish[finish]
```

## Prompt Templates

| Template | Purpose | Invocation |
|----------|---------|------------|
| `./implementer-prompt.md` | Spawn an implementer teammate | Task tool with `team_name` |
| `./spec-reviewer-prompt.md` | Dispatch spec compliance reviewer | Subagent (not teammate) |
| `review` skill | Dispatch swarm quality review (fast-pass tier) | Subagent via skill pipeline |
| `./lead-playbook.md` | Lead's orchestration decision logic | Reference for the lead |

## Key Design Decisions

### Staggered Pipeline
Reviews happen as implementers finish — no waiting for all to complete. Multiple reviews can run in parallel since they are read-only.

### Implementers Wait for Review
An implementer does NOT start their next task until both reviews pass on their current task. This prevents messy context switches when review feedback arrives.

### Lead Dispatches All Reviews
Reviewers are subagents (not teammates). They report to the lead, who decides next steps. This keeps the lead as the single quality gatekeeper.

### Lead Keeps the PRD Current
Only the lead writes to the live PRD, never implementers or reviewers. When a task passes both reviews and it is the last task of a milestone in the plan's Milestone Map, the lead ticks the milestone and logs it. Product questions raised by implementers become PRD decisions. Batch writes and follow `framework/LIVE_PRD.md`; never block the team on a PRD write.

### Lead Owns Team Memory
Like the PRD, team memory is the lead's alone: only the lead searches it in Phase 1 and saves notes in Phase 5, per `framework/MEMORY.md`. Teammates and reviewers never call it.

### Dynamic Implementer Count

| Independent Task Count | Recommended Implementers |
|------------------------|--------------------------|
| 2 | 2 |
| 3-4 | 3 |
| 5-6 | 4-5 |
| 7+ | 5-6 (cap at 6) |

Bias toward 3. Scale up when tasks are truly independent. Scale down when overlap is high.

### Reuse vs Fresh Spawn
- **Related task** (same module/directory) — reuse the teammate. Existing context helps.
- **Unrelated task** (different area) — shut down and spawn fresh. Avoids context pollution.

### File Conflict Prevention
The lead groups tasks by file surface area before spawning. Tasks touching the same files never run in parallel — they use `blockedBy` dependencies instead.

### Shared Context, Shared Machine
Teammates start blank and share the lead's working tree and machine. The lead writes one shared context doc that the implementer and spec-reviewer prompts point at, sends inventories to research subagents that write nothing, gates heavy runs, and pauses teammates with a resume file. See `./lead-playbook.md`.

## Red Flags

**Never:**
- Dispatch multiple implementers to tasks touching the same files
- Skip reviews (spec OR quality) for any task
- Let implementers start next task before current review passes
- Spawn more implementers than independent tasks
- Let implementers dispatch their own reviews (lead's job)
- Start quality review before spec compliance passes
- Move to final review while any task has open review issues

**If implementer asks questions:**
- Answer via SendMessage with the specific context they need
- Do not leave them waiting — quick turnaround keeps the pipeline moving

**If reviewer finds issues:**
- Lead sends specific feedback to implementer via SendMessage
- Implementer fixes in-place and reports back
- Lead re-dispatches the same reviewer type
- Repeat until approved — only then proceed to next stage

**If implementer gets stuck:**
- Check their pane directly
- Send guidance via SendMessage
- Last resort: shut down and spawn replacement with clearer instructions

## Integration

**Required workflow (in order):**
1. **spec** — capture requirements as acceptance contract (from a PRD when one exists)
2. **plan** — create the numbered implementation plan
3. **team-dev** — execute in parallel with quality gates
4. **finish** — merge/PR when all tasks pass

**Used during orchestration:**
- **verify** — before marking the effort done
- **review** — swarm review at fast-pass tier per task

**Implementer teammates use:**
- **tdd** — TDD for each task
- Domain skills from the team's extensions

**Alternative workflows:**

| Situation | Use Instead |
|-----------|-------------|
| Fewer than 3 independent tasks | **sdd** |
| Tasks share many files | **sdd** |
| Agent teams not enabled | **sdd** |

## Limitations

- Requires agent teams enabled (experimental feature)
- Split panes require tmux or iTerm2
- Tasks must touch different files to parallelize safely
- Higher token cost than sdd (multiple persistent sessions)
- One team per session — clean up before starting another
- Teammates cannot spawn their own teams
- Heavily coupled plans may degrade to near-sequential execution
Pliki w paczce (4)
  • SKILL.md 9 KB
  • implementer-prompt.md 4 KB
  • lead-playbook.md 11 KB
  • spec-reviewer-prompt.md 4 KB

Wersje

W bazie nie ma innych skilli o nazwie team-dev.

Migawka bazy z 13.11.2026 · wersja paczki 3167c810c7f0 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100team
    Uruchamia nazwany zespół agentów w podzielonych oknach tmux, z widocznymi, trwałymi członkami zamiast tła subagentów.
  • 100agent-teams
    Buduje zespół subagentów Claude, w którym bieżąca sesja kieruje pracą, a każdy członek zespołu działa na innym modelu.
  • 90implement-team
    Wykonuje plan wdrożenia równolegle przez podagentów dla niezależnych kroków, gdy zespół agentów ma przyspieszyć pracę.
  • 100teams
    Koordynuje zespół agentów, rozbija zadanie, uruchamia współpracowników i nadzoruje wykonanie w kilku sesjach Claude Code.
  • 100agent-teams
    Tworzy zespoły agentów do równoległej współpracy, na przykład zespół recenzentów patrzących na zadanie z różnych perspektyw.
  • 90vc:team
    Orkiestruje zespoły agentów do równoległej współpracy w wielu sesjach przy badaniach, implementacji, przeglądzie i debugowaniu z niezależnymi współpracownikami.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.