Plugin

correctless

Name: correctless
Author: joshft

Enforce configurable-rigor development workflows across 26 skills: spec-before-code planning, adversarial reviews, TDD enforcement, formal modeling, security audits, PR maintenance, safe refactors, releases, postmortems, and health metrics dashboards, gated by project intensity (standard/high/critical). Invoke via slash commands like /cspec, /ctdd, /creview anytime in any codebase.

npx claudepluginhub joshft/correctless --plugin correctless

Component Overview

Skills

Component Details

Skills (25)

caudit

/caudit

Cross-codebase quality audit. Use after a major feature lands or periodically for systemic bug detection. Presets: QA, Hacker, Performance.

ccontribute

/ccontribute

Open source contribution workflow. Learns the target project's conventions, patterns, and CI requirements before writing code. Generates a PR that matches what maintainers expect.

cdebug

/cdebug

Structured bug investigation workflow. Root cause analysis, hypothesis testing, TDD fix with agent separation, escalation after 3 failed attempts. Use when stuck on a bug.

cdevadv

/cdevadv

10th Man / Devil's Advocate. Challenges the assumptions, architecture, and strategies that every other agent accepts as true. Periodic deep analysis — not every feature.

cdocs

/cdocs

Update project documentation after a feature lands. Updates README, .correctless/AGENT_CONTEXT.md, .correctless/ARCHITECTURE.md, and feature docs. Run before merging.

cexplain

/cexplain

Guided codebase exploration with mermaid diagrams and prose walkthroughs.

chelp

/chelp

Quick help — shows the workflow pipeline, available commands, and current status.

cmaintain

/cmaintain

Maintainer review for incoming PRs. Use when you need to decide whether to merge a contribution. Checks scope, conventions, and maintenance burden.

cmetrics

/cmetrics

Project health and ROI dashboard. Use monthly or when evaluating workflow effectiveness. Shows bugs caught, token cost, and trends.

cmodel

/cmodel

Generate an Alloy formal model of security-relevant behavior and run the Alloy Analyzer. Use after /cspec for features with state machines, protocol handling, or trust boundaries.

cpostmortem

/cpostmortem

Post-merge bug analysis. Use when a bug escapes to production. Traces which phase missed it and strengthens the workflow.

cpr-review

/cpr-review

Review an incoming PR. Use when someone opens a PR against your project. Checks architecture, security, tests, and antipatterns.

cquick

/cquick

Quick fix with TDD — no spec/review for small changes. Branch, test, implement, commit.

credteam

/credteam

Live adversarial red team assessment against a running system. Goal-directed penetration testing with source code access. Requires isolated environment.

crefactor

/crefactor

Structured refactoring with behavioral equivalence enforcement. Tests must pass before AND after. Any test change requires explicit approval. Writes characterization tests for low-coverage code.

crelease

/crelease

Automate version bumping, changelog generation, and release tagging from specs.

creview-spec

/creview-spec

Multi-agent adversarial review of a spec. Spawns red team, assumptions auditor, testability auditor, and design contract checker. Use after /cspec or /cmodel.

creview

/creview

Skeptically review a spec for unstated assumptions, untestable rules, missing edge cases, and security gaps. Run after /cspec.

cspec

/cspec

Create a structured specification with testable invariants for a new feature. Researches current best practices before writing invariants. Adapts format to workflow intensity.

cstatus

/cstatus

Show current Correctless workflow state, available commands, and suggested next steps. Run anytime to see where you are.

csummary

/csummary

Feature summary. Use after /cdocs to see what the workflow caught, or mid-feature to check progress.

ctdd

/ctdd

Enforced TDD workflow. Write failing tests from spec rules, then implement. Use after /creview approves a spec.

cupdate-arch

/cupdate-arch

Update .correctless/ARCHITECTURE.md after features land. Use after /cdocs or when the codebase structure has changed.

cverify

/cverify

Verify implementation matches spec. Check rule coverage, undocumented dependencies, architecture compliance. Writes verification report and drift debt. Run after /ctdd completes.

cwtf

/cwtf

Audit the workflow itself. Use when you suspect agents shortcut or after a bug escapes despite the workflow running. Checks phase execution, rule coverage, and agent thoroughness.

README

Composable Claude Code skills that enforce a correctness-oriented development workflow. Spec before you code. Test before you implement. Never let an agent grade its own work.

The Problem

AI coding assistants are fast but sloppy. They write code that works for the happy path, skip edge cases, and silently introduce bugs that don't surface until production. The same model that wrote the code will review it and say "looks good" — because it's confirming its own decisions.

Correctless fixes this by structuring the workflow so that every phase is executed by a different agent with a different lens:

The spec agent asks "what does correct mean?" and researches current best practices before any code exists
The review agent reads the spec cold and checks for security gaps, unstated assumptions, and untestable rules
The test agent writes tests from the spec without knowing the implementation plan
The test auditor checks whether those tests would actually catch bugs or just pass against mocks
The implementation agent makes the tests pass without having written them
The QA agent hunts for bugs with neither the test author's nor the implementer's blind spots
The verification agent checks spec-to-code correspondence without insider knowledge

Same model — but the framing determines what the agent finds.

Quick Start

You need Claude Code and a Claude Max subscription ($100-200/mo).

Install

/plugin marketplace add joshft/correctless
/plugin install correctless
/csetup

Alternative: Git clone

git clone https://github.com/joshft/correctless.git .claude/skills/workflow
.claude/skills/workflow/setup
/csetup

Standard intensity by default. To increase: add "intensity": "high" or "critical" to the workflow section of .correctless/config/workflow-config.json.

First Feature

git checkout -b feature/my-feature
/cspec

Update

/plugin uninstall correctless
/plugin marketplace remove correctless
/plugin marketplace add joshft/correctless
/plugin install correctless

Then restart Claude Code. Git clone users: cd .claude/skills/workflow && git pull && ./setup

One Plugin, Three Intensity Levels

Correctless ships as a single plugin with 26 skills. You choose the intensity that matches your project's risk profile. Seven skills are gated behind intensity thresholds — they check your project's workflow.intensity setting and warn if invoked below their minimum.

Intensity	Overhead	What You Get	Best For
standard	~10-15 min	19 core skills: spec, review, TDD, verify, docs, debug, refactor, release	SaaS, APIs, CLI tools, content sites
high	~30-60 min	+ adversarial spec review, convergence auditing, architecture tracking	Auth, payments, sensitive data
critical	~1-2 hours	+ Alloy formal modeling, live red team assessment	Security infrastructure, crypto, proxies

Skills like /cpostmortem and /cdevadv are available at all intensity levels — they're about learning from the past, not adding rigor to the present.

Put another way: Standard intensity is like having someone next to you going through a checklist to make sure your project has some sanity. Critical intensity is like taking your Claude Max subscription tokens, setting them on fire, collecting the ash, and using it to create a tiny diamond.

How It Works

The Standard Workflow

graph LR
    A["/cspec<br/>Write spec"] --> B["/creview<br/>Skeptical review"]
    B --> C["/ctdd"]
    C --> D["/cverify<br/>Rule coverage"]
    D --> E["/cdocs<br/>Update docs"]
    E --> F["Merge"]

    subgraph "/ctdd — Enforced TDD"
        direction LR
        C1["RED<br/>Write tests"] --> C2["Test Audit<br/>Would tests catch bugs?"]
        C2 --> C3["GREEN<br/>Implement"]
        C3 --> C4["/simplify"]
        C4 --> C5["QA<br/>Hostile review"]
        C5 -.->|"Issues found"| C3
    end

    C --- C1

View full README on GitHub

Similar Plugins

chrome-devtools-mcp

37.4k

112

Reliable automation, in-depth debugging, and performance analysis in Chrome using Chrome DevTools and Puppeteer

Stats

Version3.0.0

Parent Repo Stars49

Parent Repo Forks2

MaintenanceExcellent

AddedApr 4, 2026

Actions

View on GitHub View README Plugin Marketplace JSON

Available In

correctless57

The Problem

Correctless fixes this by structuring the workflow so that every phase is executed by a different agent with a different lens:

The spec agent asks "what does correct mean?" and researches current best practices before any code exists
The review agent reads the spec cold and checks for security gaps, unstated assumptions, and untestable rules
The test agent writes tests from the spec without knowing the implementation plan
The test auditor checks whether those tests would actually catch bugs or just pass against mocks
The implementation agent makes the tests pass without having written them
The QA agent hunts for bugs with neither the test author's nor the implementer's blind spots
The verification agent checks spec-to-code correspondence without insider knowledge

Same model — but the framing determines what the agent finds.

Quick Start

You need Claude Code and a Claude Max subscription ($100-200/mo).

Install

/plugin marketplace add joshft/correctless
/plugin install correctless
/csetup

Alternative: Git clone

git clone https://github.com/joshft/correctless.git .claude/skills/workflow
.claude/skills/workflow/setup
/csetup

Standard intensity by default. To increase: add "intensity": "high" or "critical" to the workflow section of .correctless/config/workflow-config.json.

First Feature

git checkout -b feature/my-feature
/cspec

Update

/plugin uninstall correctless
/plugin marketplace remove correctless
/plugin marketplace add joshft/correctless
/plugin install correctless

Then restart Claude Code. Git clone users: cd .claude/skills/workflow && git pull && ./setup

One Plugin, Three Intensity Levels

Intensity	Overhead	What You Get	Best For
standard	~10-15 min	19 core skills: spec, review, TDD, verify, docs, debug, refactor, release	SaaS, APIs, CLI tools, content sites
high	~30-60 min	+ adversarial spec review, convergence auditing, architecture tracking	Auth, payments, sensitive data
critical	~1-2 hours	+ Alloy formal modeling, live red team assessment	Security infrastructure, crypto, proxies

Skills like /cpostmortem and /cdevadv are available at all intensity levels — they're about learning from the past, not adding rigor to the present.

How It Works

The Standard Workflow

graph LR
    A["/cspec<br/>Write spec"] --> B["/creview<br/>Skeptical review"]
    B --> C["/ctdd"]
    C --> D["/cverify<br/>Rule coverage"]
    D --> E["/cdocs<br/>Update docs"]
    E --> F["Merge"]

    subgraph "/ctdd — Enforced TDD"
        direction LR
        C1["RED<br/>Write tests"] --> C2["Test Audit<br/>Would tests catch bugs?"]
        C2 --> C3["GREEN<br/>Implement"]
        C3 --> C4["/simplify"]
        C4 --> C5["QA<br/>Hostile review"]
        C5 -.->|"Issues found"| C3
    end

    C --- C1

correctless

Component Overview

Component Details

Skills (25)

README

The Problem

Quick Start

Install

First Feature

Update

One Plugin, Three Intensity Levels

How It Works

The Standard Workflow

Similar Plugins

chrome-devtools-mcp

correctless

Component Overview

Component Details

Skills (25)

README

The Problem

Quick Start

Install

First Feature

Update

One Plugin, Three Intensity Levels

How It Works

The Standard Workflow

Similar Plugins

chrome-devtools-mcp

godot-claude-skills

planning-with-files

gsd-build-get-shit-done

c4-architecture

superpowers