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

code-subagents

/code-subagents

Opisuje wzorce zlecania implementacji subagentom, gdy projekt jest ustalony: kwalifikację zadań, równoległą pracę, jedno zbiorcze review na partię i szeregową integrację.

Repozytorium
atelier ↗
Licencja
MIT
Ostatnia zmiana repozytorium
25.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
3
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 25.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

Opisuje wzorce zlecania implementacji subagentom, gdy projekt jest ustalony: kwalifikację zadań, równoległą pracę, jedno zbiorcze review na partię i szeregową integrację.

Oryginalny opis (EN)

Implementation subagent dispatch patterns. Use when a task's design is settled and the file just needs to be made, or when independent implementation work can run in parallel. Covers eligibility, dispatch, shared-tree patch snapshots, one combined review per completed batch, and serial integration.

Jak działa

  1. When to Use Subagents
  2. Dispatch Modes
  3. Agent Selection
  4. Prompt Templates
  5. Batch Review
  6. Handling Subagent Questions
  7. Integrating Results
  8. When Subagents Fail
Sekcje z nagłówków SKILL.md, w oryginale · 163 linii, 906 słów
Podgląd SKILL.md
---
name: code-subagents
description: >
  Implementation subagent dispatch patterns. Use when a task's design is settled and the file
  just needs to be made, or when independent implementation work can run in parallel. Covers
  eligibility, dispatch, shared-tree patch snapshots, one combined review per completed batch,
  and serial integration.
user-invocable: false
---

# Implementation Subagents

Fresh subagent per task. One combined review per completed batch. Parallel when independent,
sequential when dependent.

## When to Use Subagents

**Use when** (all must hold):
- The design is settled: the plan or `design.md` already specifies what the file contains
  (types, signatures, schema, contract, or an existing pattern to copy)
- The work item has explicit requirements, owned files, and a validation command
- It does not share files or state with other in-flight work

Prime candidates are new files, scaffolding, boilerplate, and pattern-following edits.
Parallelism is a separate question: dispatch two or more eligible items concurrently only when
the independence check below passes.

**Don't use when:**
- Tasks are tightly coupled (editing the same files)
- You need to understand full system state across tasks
- Failures are related (fixing one might fix others)
- Exploratory work where the problem isn't well-defined yet

## Dispatch Modes

### Sequential (dependent tasks)

Tasks with dependencies execute one at a time. Each gets a fresh subagent — no context
pollution from previous tasks.

```
Task 1 (Entity) → review → complete
Task 2 (Repository, depends on T1) → review → complete
Task 3 (Service, depends on T2) → review → complete
```

### Parallel (independent tasks)

Independent tasks dispatch simultaneously. One agent per problem domain.

```
Task A (auth tests) ──→ review → complete
Task B (billing tests) ──→ review → complete    ← concurrent
Task C (notification tests) ──→ review → complete
```

**Independence check:** Would fixing Task A affect Task B? Would they edit the same files?
If no to both, dispatch in parallel.

For shared-tree parallel work:

1. Assign each task an exclusive file list before dispatch
2. Do not let implementers stage or commit changes
3. Capture full `git status`, including untracked files, before and after each task
4. Capture the task's path-scoped patch and reject changes outside its assigned paths
5. Run tasks sequentially if their file ownership overlaps or cannot be isolated

---

## Agent Selection

Select the agent explicitly for every dispatch (see Delegation in `atelier-orchestrator`). Give
implementers the design excerpt so they make no design decisions: mechanical file creation should
match a scaffolder; design-sensitive implementation may use the harness's general agent, the one
permitted exception to selecting from Atelier's agents. The batch reviewer is a read-only
critical review.

---

## Prompt Templates

Use these templates when dispatching subagents. Each template is battle-tested — don't
improvise, use them as-is and fill in the variables.

- **[references/implementor-prompt.md](references/implementor-prompt.md)** — Dispatch an implementer. Includes self-review checklist.
- **[references/batch-reviewer-prompt.md](references/batch-reviewer-prompt.md)** — Combined plan and code-quality review for one completed batch.

### Prompt quality rules

- **Focused** — one task, one problem domain
- **Self-contained** — all context needed is in the prompt. Provide the complete work-item
  requirements; do not make the subagent recover context
- **Specific about files** — exact paths, not "the relevant files"
- **Specific about output** — what should the subagent return?
- **Constrained** — what should they NOT touch?

### Common mistakes

| Mistake | Fix |
|---------|-----|
| "Fix all the tests" | "Fix the 3 failures in user.test.ts" |
| No context about codebase | Paste the relevant patterns and conventions |
| No constraints | "Do NOT change production code" or scope to specific files |
| Vague output expectations | "Return: root cause, changes made, test results" |

---

## Batch Review

Run one combined review after every completed batch, not separate reviews for each task.

Give one fresh reviewer:

- The complete requirements for work items in the batch
- The relevant constraints
- The path-scoped patch captured for each task
- The full changed-file inventory, including untracked files
- The implementers' reports and validation results

The reviewer checks both requirements compliance and code quality:

1. Every requirement and acceptance criterion is implemented
2. The batch follows the supplied constraints
3. No unrequested work or out-of-scope files are included
4. Tests are meaningful and cover the right boundaries
5. The code follows existing patterns without unnecessary complexity

Use [references/batch-reviewer-prompt.md](references/batch-reviewer-prompt.md) as written.

If the reviewer finds Critical or Important issues, send each issue back to the relevant
implementer, refresh its path-scoped patch, and review the batch again. Minor issues may be
noted and moved past.

---

## Handling Subagent Questions

Subagents may ask questions before or during implementation. This is good — it means
they're thinking rather than guessing.

- Answer clearly and completely
- Provide additional context if needed
- Don't rush them into implementation
- If the question reveals a gap in the plan, that's valuable — note it

---

## Integrating Results

After subagents complete (especially parallel dispatch):

1. **Read each summary** — understand what changed
2. **Capture task patches** — use each task's exclusive file list
3. **Review the batch** — one combined requirements and quality review
4. **Run full test suite** — verify all changes work together
5. **Commit** — the coordinator commits the reviewed batch serially
6. **Update progress tracking** — when the caller uses it

If there are conflicts between parallel results, resolve them manually. Don't dispatch
another subagent to merge — that requires too much context.

---

## When Subagents Fail

If a subagent fails a task:

- **Don't fix it manually** — that pollutes your context
- **Dispatch a fix subagent** with specific instructions about what went wrong
- **If it fails twice**, stop and escalate to the human. The requirements or constraints may
  need revision.
Pliki w paczce (3)
  • SKILL.md 6 KB
  • references/batch-reviewer-prompt.md 1 KB
  • references/implementor-prompt.md 2 KB

Wersje

W bazie nie ma innych skilli o nazwie code-subagents.

Migawka bazy z 13.11.2026 · wersja paczki 8fae0179b1fc (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

  • 100subagent-orchestration
    Opisuje, kiedy i jak delegować pracę subagentom przez narzędzie subagent (Explore, Plan, General): rekonesans kodu, planowanie implementacji i zmiany w kodzie w izolowanym oknie kontekstu.
  • 100subagent-dispatch
    Przekazuje pracę subagentowi: wdrożenie, przegląd, badania lub eksplorację, gdy zadanie korzysta z świeżego kontekstu lub równoległości.
  • 100subagent-delegation
    Deleguje rutynową pracę subagentom: generowanie szablonów kodu, transformację danych, analizę plików i szkice dokumentacji, przy podziale zadań na niezależne podzadania.
  • 100subagent
    Uruchamia jednorazową, równoległą partię subagentów LLM od różnych dostawców, zwracających wyniki, np. przy pracy na wielu plikach.
  • 100subagent-driven-development
    Wykonuje plany implementacji z niezależnymi zadaniami w bieżącej sesji, uruchamiając świeżego subagenta na zadanie z dwuetapowym przeglądem: zgodność ze specyfikacją, potem jakość kodu.
  • 100dispatch-multiple-agents
    Rozdziela dwa lub więcej niezależnych zadań bez wspólnego stanu i kolejności na subagentów, którzy pracują równolegle.

Uwagi i zgłoszenia

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