crucible

Crucible

Not Another Code Reviewer.

A Claude Code plugin that runs your code through a corporate review pipeline. A Profiler reads your project, interviews you about the phase, and casts a 4–8 persona review committee from a 23-persona library. Peers review at the code level, departments hunt for gaps, and leadership grades alignment to your stated aims. An Aggregator synthesizes the holistic verdict — no math, no averaging, just Opus reasoning over the committee's reports.

The output is a live terminal stream while the pipeline runs and a fully-detailed markdown report saved at .review/reports/<id>.md. See examples/ for sample reports.

Why this exists

Every Claude Code plugin's reviewer fans out agents in parallel and aggregates their findings. Crucible is structurally different in three ways:

1. Adaptive cast. A Profiler reads your project and picks the right reviewers from a 23-persona library. A Next.js auth refactor casts TypeScript + SQL + Security + Backend + Database + Architect + PM. A PyTorch training change casts Python + Quality + Data-ML + Performance + Architect + PM. The committee fits the work.
2. Three altitudes. Stage 1 peers review at the code level (idioms, bugs, quality). Stage 2 cross-functional reviewers hunt for gaps (security, performance, accessibility, observability — domain-specific lenses). Stage 3 leadership reasons at the strategic level (architectural coherence, aim alignment).
3. Aim alignment. A lead-project-manager persona reads your .review/aims.md — written interactively by the Profiler — and grades the change against your stated success criteria. Nobody else does this. Your code isn't graded in a vacuum; it's graded against what you said you were trying to do.

The result: every persona reasons in their lane, the stages hand off structured findings, and one final reasoning agent synthesizes everything into a single score, verdict, and curated executive summary. No mechanical roll-up; the Aggregator weighs signals as a thoughtful executive would when reading a 7-person review committee.

Quick start

Inside Claude Code, add Crucible as a self-hosted marketplace and install the plugin (one-time setup):

/plugin marketplace add hazarsozer/crucible-cc
/plugin install crucible@crucible
/reload-plugins

Then, in any project directory:

cd your-project
/crucible:run

npx claudepluginhub hazarsozer/crucible-cc --plugin crucible

git clone https://github.com/hazarsozer/crucible-cc.git
claude --plugin-dir ./crucible-cc

Optional commands:

/crucible:aims      # refresh .review/aims.md without running a full review
/crucible:history   # list past reviews stored in .review/reports/

The first run of /crucible:run will:

1. Read your project files (file tree, README, language manifests, recent commits).
2. Detect project type (web-app, api, ml-pipeline, cli, library, mobile, data-pipeline, mixed).
3. Interview you about the phase: goal, success criteria, non-goals, constraints.
4. Write .review/aims.md and update .gitignore if needed.
5. Ask what to review (full project, phase, files, branch diff).
6. Cast the committee and confirm with you before dispatching.
7. Run the 5-stage pipeline and write the report.

Subsequent runs reuse .review/aims.md (with a "still accurate?" prompt).

⚠️ When NOT to use /crucible:run

Crucible runs 5 stages and 4–8 specialized agents per review. It is not another lightweight reviewer — it is a corporate-review simulation, and that shape costs tokens.

Use /crucible:run for:

• Full-project reviews (initial audit, pre-release, milestone gate)
• Partial-implementation reviews (a feature, a phase, a refactor in flight)

Don't use /crucible:run for:

• A single script or one-file change
• Trivial PRs or one-line tweaks
• Anything where one specialist's perspective is enough

For those, call a specific persona directly via the Task tool — crucible:peer-python-reviewer, crucible:team-security-reviewer, crucible:lead-senior-architect, etc. The full list of 23 personas is below; each is independently invokable. The pipeline is the heavyweight; individual personas are the scalpel.