Correctless

/cauto — Semi-Auto Implementation Pipeline

Orchestrate the full implementation pipeline after spec review. Runs /ctdd, /simplify, /cverify, /cupdate-arch, /cdocs, then creates a PR — with flexible phase resume and autonomous decision-making.

When to Use

After /creview (or /creview-spec) approves a spec — this runs the entire implementation pipeline
When you want hands-off execution from TDD through PR creation
When resuming a pipeline that was interrupted (escalation, context overflow, hard stop)
Not for: features that don’t have an approved spec yet (run /cspec and /creview first)

How It Fits in the Workflow

/cauto is the pipeline orchestrator. Instead of manually running /ctdd → /cverify → /cdocs → PR, /cauto runs them all in sequence, handling failures, retries, and escalation. It respects the same workflow state machine as manual invocation — skills still run in separate agents with context: fork. The orchestrator invokes skills; skills do not auto-continue on their own.

What It Does

Phase gate — reads the current workflow phase and computes remaining pipeline steps. Accepts any active phase from review through documented. Rejects spec and model (spec must be reviewed first).
Install freshness check — detects stale hooks before any skill runs. Warns if source files changed since last setup.
Invoke /ctdd — spawns a sub-agent for the full RED → GREEN → QA → mini-audit cycle. If TDD triggers a spec-update, escalates to the human.
Commit before /simplify — creates a clean revert point (“TDD complete”).
Invoke /simplify — runs Claude Code’s built-in simplification. Post-simplify validation reverts if tests fail or .correctless/ paths were modified.
Invoke /cverify — verifies implementation matches spec.
Invoke /cupdate-arch (high+ intensity only) — updates architecture documentation.
Invoke /cdocs — updates project documentation.
Consolidation — scoped commit and push. Only stages known pipeline output paths. Belt-and-suspenders guard prevents committing artifacts.
Create PR — via gh pr create (default), skip, or custom command. PR body includes summary, test plan, QA findings, and verification status.

Escalation

When a failure persists after N attempts (3 at standard, 2 at high/critical), the pipeline stops and writes a structured escalation file. Re-running /cauto after the human resolves the issue resumes from where it left off.

Phase 2: Tiered Decision Architecture

Decisions are routed through a tiered hierarchy: Policy (deterministic) → Worker (self-resolution) → Decision Agent (ephemeral) → Supervisor (lightweight) → Hard Stop (human). Token and time budgets are enforced with warn at 75% and hard stop at 100%.

Phase 3: Spec-to-PR Orchestration

When no workflow exists, /cauto can start from scratch — running /cspec interactively or accepting a provided spec file. Autonomous review with supervisor triage incorporates findings automatically. A mandatory spec approval gate always requires human confirmation before implementation begins.

Example

Agent: Reading workflow state... phase is "review". Full pipeline ahead.
       Checking install freshness... all hooks current.
       Reading preferences... pr_creation: gh, defaults for all others.

       Starting /ctdd...
       [RED → test audit → GREEN → /simplify → QA → mini-audit]
       /ctdd complete. Committing TDD changes.

       Running /simplify... accepted (tests pass, no protected paths modified).

       Starting /cverify...
       Verification complete — 5/5 rules covered, 0 smells.

       Skipping /cupdate-arch (standard intensity).

       Starting /cdocs...
       Documentation updated.

       Consolidation: staging pipeline outputs...
       Pushed to origin/feature/my-feature.

       Creating PR via gh...
       PR #42 created: https://github.com/user/repo/pull/42

       Pipeline Summary:
       ┌──────────────┬──────────┬────────┬────────┐
       │ Step         │ Duration │ Tokens │ Result │
       ├──────────────┼──────────┼────────┼────────┤
       │ ctdd         │ 8m 12s   │ 45,200 │ pass   │
       │ simplify     │ 0m 34s   │ —      │ pass   │
       │ cverify      │ 1m 05s   │ 8,300  │ pass   │
       │ cupdate-arch │ —        │ —      │ skip   │
       │ cdocs        │ 2m 18s   │ 12,100 │ pass   │
       └──────────────┴──────────┴────────┴────────┘

What It Reads / Writes

Reads	Writes
Workflow state (`.correctless/artifacts/workflow-state-{slug}.json`)	All artifacts from invoked skills
`.correctless/config/workflow-config.json`	`.correctless/artifacts/audit-trail-{slug}.jsonl`
`.correctless/preferences.md`	`.correctless/artifacts/escalation-{slug}.md` (on failure)
`.correctless/config/auto-policy.json` (Phase 2)	`.correctless/meta/overrides/{slug}-{date}.json`
Approved spec	PR on GitHub

Intensity Levels

Aspect	Standard	High	Critical
Pipeline	ctdd → simplify → cverify → cdocs → PR	+ cupdate-arch	+ cupdate-arch
Failure threshold	3 attempts	2 attempts	2 attempts
Supervisor activations	Same	Same	Same

Common Issues

“Run /creview first”: The spec must be reviewed before /cauto can run. Run /creview or /creview-spec first.
Escalation during /ctdd: Usually a spec issue — the spec contradicts implementation reality. Fix the spec and re-run.
Push failure: Auth or rejected push. The local commit is preserved. Fix the issue and re-run — the phase gate routes to PR-only.
“gh CLI not installed”: Set pr_creation: skip in .correctless/preferences.md or install gh.
Context overflow: Each skill runs in a fresh context via context: fork. If the orchestrator itself overflows, re-run — the checkpoint system saves progress.

This site is open source. Improve this page.