consort
/consort
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.
- Author
- siimvene ↗
- Repository
- consort ↗
- Licence
- MIT
- Last repository change
- 18.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 18.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
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.
Original author 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.
How it works
- Inputs
- Run the phases in order. Write each artifact before advancing.
- Output
SKILL.md preview
--- 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.
Versions
The database has no other skills named consort.
Database snapshot: 13.11.2026 · package version b3b4bd46bf84 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 87implementation-loop
Delegate implementation to Codex or to a sandboxed Claude Code (`claude -p`), have a model from the other vendor review the diff, send it back to iterate, gate on the full test suite, and ship it as a PR. Use this whenever the user wants Codex or a sandboxed Claude to write… - 100ai-orchestrator
Build a whole feature end-to-end through subagents. It plans gated checkpoints, writes tests and prototypes, then loops each checkpoint through implement → behavior gate (CLI/code tests, UI e2e last) → UI gate (live vs prototype) → adversarial review gate until every checkpoint… - 100cross-review
Cross-model review — hands the current branch diff to Codex (OpenAI), a different model than the one that wrote the code, running the `delivery-reviewer` Codex skill against the base branch. Use as step 5 of /delivery:task, or when the user asks to "review this branch with… - 100codex-plan-review
Cross-provider adversarial review of a finalized plan, spec, design doc, ADR, or code diff using OpenAI Codex (GPT-6 Sol), paired in round 1 with a blind Opus reviewer. AUTO-TRIGGER at plan gates — invoke immediately after any of: (1) a plan or spec is finalized, (2) an ADR… - 100factory-orchestrate
Runs an end-to-end software factory. Takes an idea or backlog through spec, design, vertical-slice tickets, parallel implementation by agents in isolated worktrees, review by a different model family, guarded merge, and a final check against the spec. Built for multi-model… - 90implement-spec-with-codex
Run [implement-spec](../implement-spec/SKILL.md) with Codex doing the implementation passes while you orchestrate, integrate, and review. Use when the user asks to implement a spec with Codex, or to run implement-spec with Codex as the implementer.