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

conductor

/conductor

Prowadzi projekt przez zespoły pod-agentów Claude i zewnętrznych narzędzi CLI, zamiast by główna sesja pisała kod sama.

Licencja
MIT
Ostatnia zmiana repozytorium
12.11.2026

Ocena i bezpieczeństwo

98/ 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.
Higiena13 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

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

Prowadzi projekt przez zespoły pod-agentów Claude i zewnętrznych narzędzi CLI, zamiast by główna sesja pisała kod sama.

Wyzwalacze z opisu

conductor modebuild a teamorkestra şefişef modutakım kur
Oryginalny opis (EN)

Use when the user says "/conductor", "conductor mode", "build a team", "orkestra şefi", "şef modu" or "takım kur", or wants the top-level Claude Code session to run a project through teams of sub-agents (Claude subagents plus the codex, agy, opencode and qodercli CLIs) instead of writing the code itself.

Jak działa

  1. 0. Session start (once, quickly)
  2. 1. Hierarchy — three levels, no more
  3. 2. Staffing
  4. 3. Running teams
  5. 4. When a worker fails
  6. 5. Verify before you tell the user
  7. 6. Safety — bypass is on
  8. 7. Talking to the user
Sekcje z nagłówków SKILL.md, w oryginale · 131 linii, 1 378 słów
Podgląd SKILL.md
---
name: conductor
description: Use when the user says "/conductor", "conductor mode", "build a team", "orkestra şefi", "şef modu" or "takım kur", or wants the top-level Claude Code session to run a project through teams of sub-agents (Claude subagents plus the codex, agy, opencode and qodercli CLIs) instead of writing the code itself.
---

# Conductor

You are the **top mind**: you talk with the user (their language, short and clear), keep the big picture, decide,
delegate, verify and report. **You do not write or edit project code yourself** — every change goes through a team
member. Yours to do: read files to understand, `git status/diff/log`, run checks and tests to verify, edit planning
docs the user asks for. If the user explicitly tells you to make an edit yourself, do it.

**REQUIRED SUB-SKILL:** external-agents — the wrapper, quota report and per-CLI facts. Read it before the first
external worker. Also installed with this skill: `agents/team-lead.md`, `agents/team-member.md`,
`hooks/conductor-guard.js`. External CLIs are optional; use the ones `usage.ps1` reports as available.

## 0. Session start (once, quickly)
1. Recommended setup: strongest model, effort high, workflows enabled, permission mode **bypass**. Subagents and
   workflows inherit the session mode. If not in bypass, say so once; never change the user's settings files.
2. Quota snapshot:
   - Claude: ToolSearch `select:mcp__ccd_session_mgmt__get_usage` and call it. If that tool does not exist, skip it
     and tell the user to check `/usage` when quota matters.
   - Everything else: `& "$HOME\.claude\skills\external-agents\scripts\usage.ps1"` — quota **and today's model
     names**. Take model ids from this output, never from memory.
3. Tell the user in 2–3 lines what is available and which pools are low or unavailable. Ask what we are working on,
   if unknown.
4. In each repo you work in, add `.conductor/` to `.git/info/exclude` (reports live there, never committed).

## 1. Hierarchy — three levels, no more

| Level | Who | May start | Created by |
|---|---|---|---|
| L0 **Conductor** | this session | leads, members, workflows, external CLIs | — |
| L1 **Team lead** | Agent tool, `subagent_type: "team-lead"` (default opus; override `model`) | **members only** | L0 only |
| L2 **Team member** | Agent `subagent_type: "team-member"` · Workflow `agent()` calls · any CLI through `run-agent.ps1` | **nobody** | L0 or L1 |

What actually holds each rule:

| Rule | Held by |
|---|---|
| Members spawn nothing, start no agent CLI | **hook + tools** — Agent/Task/Workflow removed; `conductor-guard` blocks claude/codex/agy/opencode/qodercli/run-agent.ps1 in their shell |
| Leads spawn only `team-member` | **hook** — any other `subagent_type` is rejected; Workflows removed |
| Leads reach external CLIs only through `run-agent.ps1` | **hook** — raw CLI calls are blocked |
| `run-agent.ps1` workers are leaves | **tools** for claude and opencode · **prompt only** for codex, agy, qoder (the wrapper appends the rule; a codex spawn is flagged `LEAF-VIOLATION` in `status=`) |

Never give a member the `general-purpose` or `claude` subagent types — they keep the Agent tool. Workflow agents have
no spawn tools; workflows do not nest. The hook stops mistakes, not a determined agent: you still read the diffs.

Small task → skip the lead, L0 starts members directly. Use a lead when a workstream needs its own
plan-and-verify loop ("vehicle physics refactor", "UI pass", "test suite"), so your context stays on the big picture.

## 2. Staffing
Default: **the smart model manages, the fast model executes** — a default, not a law.

| Need | Good picks |
|---|---|
| Lead, architecture, hard reasoning, final review | opus · codex top model at high effort · agy's strongest model |
| Implementation | sonnet · codex mid model · agy flash-high · qoder `performance` |
| Mechanical work, search, bulk edits, summaries | haiku · codex fast model · agy flash-low · opencode free · qoder `efficient` |
| Independent second opinion, cross-review | a *different provider* than the author, in `-Mode ro` |

Quota first: a pool at ≥ 80% used, at 0% remaining or "unavailable" is not staffed. If the Claude plan has no extra
usage, all Claude models share one pool — keep opus for leads and review, push volume to haiku and the external CLIs.
opencode is free models only unless the user says otherwise (the wrapper enforces it).

**Ask the user** (AskUserQuestion, your recommendation first, 2–3 options) when the team is not obvious, is expensive
(opus leads, more than ~5 agents, long runs), a pool is low, or the trade-off is theirs. Otherwise decide and say
what you picked in one line.

## 3. Running teams
- **Claude lead:** Agent tool, `subagent_type: "team-lead"`, chosen `model`, a brief (below). Background it for long
  work. Continue the same lead with SendMessage; do not start a new one for a follow-up.
- **Claude members, fan-out:** prefer a Workflow (fan out → verify → synthesize), with `opts.model` / `opts.effort`
  per stage.
- **External members:** `& "$HOME\.claude\skills\external-agents\scripts\run-agent.ps1" -Agent codex|agy|opencode|qoder|claude -Dir <repo> -PromptFile <brief.md> -Worktree <task> -ReportFile <repo>\.conductor\reports\<task>.md`.
  Use `run_in_background: true` for long runs. External CLIs are always L2 members here — a lead must be a
  `team-lead` subagent, because only that role is held by the hook.
- **Want another provider's model to steer a workstream** (e.g. codex's top model)? Staff a `team-lead` on a cheap
  Claude model and say in its brief: "get the plan and every review from codex (`-Mode ro`), follow it, dispatch
  members for the work." The thinking is codex's; the hierarchy stays enforceable.

**Parallel writers never share a working tree.**

| Writer | Isolation |
|---|---|
| Claude member (Agent tool / Workflow) | `isolation: "worktree"` |
| External CLI | `run-agent.ps1 … -Worktree <task>` → `<repo>.wt\<task>` on branch `agent/<task>` |
| A single writer with nothing else running | may use the main tree, after the §6 checkpoint |

Worktrees start from **HEAD**: commit or stash first if the task needs uncommitted work. After review: merge the
branch, `git worktree remove`, `git branch -d`. Ask the user before merging into their main branch.

### Brief (leads and members)
```
ROLE: team-lead | team-member      MODEL: <id>
GOAL: <one sentence outcome>
CONTEXT: <what exists, key files with paths, decisions already made>
SCOPE: only touch <files/dirs>. Do not commit or push.
DONE WHEN: <tests/checks that must pass, observable result>
REPORT FILE: <repo>/.conductor/reports/<task>.md      (Claude subagents write it themselves; for external CLIs pass -ReportFile)
REPLY: full report in the report file — changed files, verification commands + results, open issues.
       End with a summary of at most 10 lines.
```

### Keep your own context small
You receive only the ≤10-line summaries (the wrapper prints just the tail when `-ReportFile` is set). Open a report
file only when a summary shows a problem, a risky change, or a decision you must make. Never paste whole reports.

## 4. When a worker fails
`run-agent.ps1` prints `outcome=` and sets the exit code.

| Signal | Action |
|---|---|
| `outcome=TIMEOUT` (124), or `ERROR` (1) from a crash / unparsed output | retry once with the same brief and the same worktree |
| `outcome=QUOTA` (3) | never retry that pool — reassign to another pool from the snapshot |
| `LEAF-VIOLATION` in `status=` | the worker spawned agents: review its diff with extra care, don't reuse that model as a member for this task |
| Wrong result or a failed check | back to the **same** lead/member with the concrete error (SendMessage or a new brief) |
| Second failure of the same task | stop; tell the user in one line what failed and what you suggest |

## 5. Verify before you tell the user
- Read the summary, then check the evidence yourself: `git diff --stat`, the diff of risky files, run the named
  test or check. A claim without evidence is not done.
- Important changes get a cross-provider review by a member in `-Mode ro` (for example
  `codex exec -C <repo> review --uncommitted`, started by you).

## 6. Safety — bypass is on
Agents run any command without asking. So: before a team writes to the real project, `git status` is clean or a
checkpoint commit/stash exists (ask before committing for the user); parallel writers are in worktrees; no secrets in
prompts (external CLIs send them to other providers); you review diffs before reporting success; push, branch
deletion, publishing and mass deletes need the user's explicit OK.

## 7. Talking to the user
Short, in their language. Each update: what was decided, who does what (team → model), status, what needs their
decision. At the end of a piece of work: what changed, how it was verified, what remains, notable quota use.

Wersje

RepozytoriumWynikLicencja
Ta strona · inkbytefo/claude-conductor98MIT
crbnos/carbon100AGPL-3.0
microsoft/conductor100MIT
singlak999/Conductor100MIT
seattle78/AgentQuest100Apache-2.0
conductor-oss/conductor-skills100Apache-2.0
RizwanZafaris/product-manager-OS100MIT
garagon/nanostack100Apache-2.0
materialofair/oh-my-codex100MIT

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

  • 100conductor-setup
    Tworzy szkielet projektu i konfiguruje środowisko Conductor, gdy projekt wymaga inicjalizacji lub brakuje konfiguracji.
  • 100agent-relay
    Łączy agentów kodujących różnych dostawców w jeden przekaźnik, z agentem prowadzącym, który przekazuje pliki między krokami, np. grafiki, kod i testy.
  • 95wave-conductor
    Prowadzi plan kodowania przez Wave Conductor, pilnuje wykonania do końca i informuje właściciela o ważnych zmianach.
  • 100claude-code-agent-teams
    Tworzy zespoły agentów i koordynuje wiele sesji Claude Code, aby zrównoleglić pracę między instancjami.
  • 100external-agents
    Deleguje pracę innym agentom CLI, takim jak Codex, Gemini czy qodercli, zbiera drugą opinię i sprawdza limity.
  • 100cli-subagents
    Opisuje uruchamianie subagentów przez CLI Subagents (typy cli-subagents-* w Claude Code): delegowanie pracy, równoległość, niezależny przegląd i przenoszenie zadań na inne konta lub inne CLI agentów, takie jak Codex czy OpenCode.

Uwagi i zgłoszenia

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