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

consort

/consort

Prowadzi funkcję od pomysłu do zatwierdzonej gałęzi: wywiad, specyfikację, plan, wdrożenie przez inny model i recenzję.

Repozytorium
consort ↗
Licencja
MIT
Ostatnia zmiana repozytorium
18.10.2026

Ocena i bezpieczeństwo

90/ 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ść25 / 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
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

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

Prowadzi funkcję od pomysłu do zatwierdzonej gałęzi: wywiad, specyfikację, plan, wdrożenie przez inny model i recenzję.

Oryginalny opis (EN)

Drive a full multi-vendor development lifecycle — interview, spec, plan, implement, review, gate — as the orchestrating principal, delegating implementation to a cross-vendor implementer (Codex by default) and cross-reviewing with consort. Use to take a feature request from idea to a reviewed, gated branch in one orchestrated run.

Jak działa

  1. Inputs
  2. Run the phases in order. Write each artifact before advancing.
  3. Output
Sekcje z nagłówków SKILL.md, w oryginale · 86 linii, 731 słów
Podgląd SKILL.md
---
name: consort
description: Drive a full multi-vendor development lifecycle — interview, spec, plan, implement, review, gate — as the orchestrating principal, delegating implementation to a cross-vendor implementer (Codex by default) and cross-reviewing with consort. Use to take a feature request from idea to a reviewed, gated branch in one orchestrated run.
version: 0.5.0
---

# consort — run the whole lifecycle

You are the **principal** — the model running this session. You hold the thread across every phase, make the
judgment calls, and never write bulk implementation code yourself — that goes to sol.
All phase state lives in `<workdir>/.consort/` so the run is resumable from disk.

Scripts referenced below live under `$CLAUDE_PLUGIN_ROOT` (the consort plugin root).
Set `CONSORT_IMPL_MODEL` to override the implementer model (default `gpt-6.1-sol`).

## Inputs

- A **workdir**: a git repo containing `REQUEST.md` (the feature request). Bootstrap a
  throwaway one with `scripts/consort-demo.sh <dir>`.

## Run the phases in order. Write each artifact before advancing.

### 1. Interview → `.consort/interview.md`
Read `REQUEST.md`. As principal, list what's unambiguous and what's genuinely unclear
(this is groundwork, not a panel draft). Then get **each vendor's divergent questions**
independently and in parallel — the ones a fresh reader would ask that you didn't:
- **sol (OpenAI):** `consort-consult.sh schemas/spec.schema.json "<REQUEST + 'list the questions and edge cases this request leaves open'>"`.
- **A fresh Anthropic-vendor agent** (non-inheriting subagent, per phase 2) with the same brief.

Fold in the real gaps both surface. **Gate: if ambiguity is high, ask the human; else record assumptions and continue.**

### 2. Spec (panel) → `.consort/spec.md`
**Do not author a panel draft yourself.** As principal you investigate (groundwork),
score, and synthesize — but the drafts must come from independent agents so the panel
is genuinely blind. Get **two independent blind drafts in parallel**:
- **sol (OpenAI):** `consort-consult.sh schemas/spec.schema.json "<REQUEST + 'write a spec'>"`.
- **A fresh implementer-tier agent for your own vendor (Anthropic):** spawn it with the
  same brief in a **non-inheriting** context (Claude Code: the Task/Agent tool with a
  non-`fork` subagent_type — `fork` inherits your context and defeats independence).
  Have it write its draft to `.consort/spec-<vendor>.json` and return only a short pointer.

You now hold ≥2 blind drafts, neither anchored to your orchestration context. **Score**
each on coverage, assumptions surfaced, failure modes, testability. **Synthesize** one spec
from the best, grafting the unique good ideas from the others, and record which idea came
from which voice. **Gate: human approves the spec.**

> Why not draft it yourself: the principal already holds the REQUEST framing and all prior
> context, so a principal-authored draft is not blind to that framing — it converges with
> the synthesis instead of diverging from it. An independent spawned agent per vendor is the
> only way both voices are truly independent. (Falls back to a principal-inline draft only
> if the principal's runtime cannot spawn subagents.)

### 3. Plan → `.consort/plan.md`, `.consort/tasks.json`
Decompose the spec into a short ordered task list (each task: id, goal, definition of done).
Have sol refute the plan: `consort-consult.sh schemas/findings.schema.json "<plan + 'what breaks, what is missing, what assumption is wrong'>"`. Reconcile valid objections. **Gate: plan survives refutation.**

### 4. Implement (delegate to sol)
For each task, write a five-part brief to a temp file and run:
`consort-delegate.sh <task-id> <brief-file> <workdir>`. sol implements in a workspace-write
sandbox and returns a task-result. Read the result; if `blocked`, resolve or escalate. Do
not write the implementation yourself.

### 5. Review (consort) → `.consort/review.md`
Read the built-in methodology packs in `"$CLAUDE_PLUGIN_ROOT"/rules/`, plus
`CONSORT_RULE_PACKS` if set or a repo-local `.claude/rules/` directory if
present (the script injects the same packs into sol) and apply them to your
own pass; run
the blast-surface sweep on the diff and the scanner tier
(`consort-scan.sh <workdir> > .consort/scan.json`, per
`rules/security-review.md`). Produce your own findings
(schemas/findings.schema.json). Get sol's: `consort-panel.sh` on the
workdir (one `consort-review.sh` leg per entry of `CONSORT_REVIEWERS`,
default `codex`; a failed leg is a failed review). In parallel, spawn the plugin's
`security-reviewer` agent (non-inheriting) on the same diff — its findings
join `review.md` as a **Security agent** section, verified like any
cross-model lead. Merge:
`merge-findings.mjs <your.json> <every leg file the panel manifest lists>`, then append the triaged scanner
findings from `.consort/scan.json` to `review.md` as a **Scanners** section.
Resolve every critical/high before advancing — scanner findings included; a
reachable scanner critical (live credential, critical CVE in a dependency this
change adds) gates exactly like a model finding.

### 6. Gate (no model) → exit code
`consort-gate.sh <workdir>`. Structural checks + tests. Must exit 0.

## Output

A branch with the implemented feature, all `.consort/` artifacts, and a green gate.
Report: what each phase produced (one line each) and the final gate result. Verbose
output stays in `.consort/`; your summary stays short.

Wersje

W bazie nie ma innych skilli o nazwie consort.

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

  • 87implementation-loop
    Zleca implementację modelowi Codex lub odizolowanemu Claude Code, recenzję drugiemu dostawcy i iteruje, aż testy przejdą.
  • 100ai-orchestrator
    Buduje całą funkcję przez subagentów: plan z bramkami, testy, prototypy oraz pętle wdrożenia, przeglądu i testów, aż do przekazania człowiekowi do oceny.
  • 100cross-review
    Przekazuje różnicę bieżącej gałęzi do Codexa jako drugiego modelu do przeglądu, tylko do odczytu, a poprawki wykonuje dopiero na prośbę.
  • 100codex-plan-review
    Prowadzi międzydostawcowy przegląd adwersaryjny zatwierdzonego planu, specyfikacji, ADR lub diffa kodu przez OpenAI Codex, w pierwszej rundzie wraz ze ślepym recenzentem Opus.
  • 100factory-orchestrate
    Prowadzi fabrykę end-to-end: od pomysłu przez specyfikację, zadania i równoległe wdrażanie do przeglądu innym modelem i scalenia.
  • 90implement-spec-with-codex
    Uruchamia implement-spec tak, że przebiegi implementacyjne wykonuje Codex, a ty orkiestrujesz, integrujesz i recenzujesz, gdy użytkownik chce wdrożyć specyfikację z Codexem jako wykonawcą.

Uwagi i zgłoszenia

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