Skip to content
Skills Library
AI & agents · Building & coding

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.

Repository
consort ↗
Licence
MIT
Last repository change
18.10.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 18.10.2026, without references to retired models or APIs.

Licence

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

  1. Inputs
  2. Run the phases in order. Write each artifact before advancing.
  3. Output
Original SKILL.md headings · 86 lines, 731 words
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.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.