circuit

Automate your Claude Code workflows with a single command.

Just enter /circuit:run and describe your task. It'll pick the most suitable workflow from the core set -- or from ones you've created -- and execute it, making sure each step's output is valid before moving onto the next.

• Orchestrate your skills. You can pre-configure any skill(s) be applied at the phase or step level.
• Resumable. If a session dies, you can still pick up where you left off.
• Adjustable autonomy. Steer with periodic checkpoints or let it run overnight.
• Effort levels. Rigorous by default; a lighter touch when needed.

Get Started

Install from the plugin marketplace:

/plugin marketplace add petekp/circuit
/plugin install circuit@petekp
/reload-plugins

Start a new Claude Code session and run:

/circuit:run {{your task}}

Circuit classifies your task, picks the right workflow, and runs it.

How It Works

Circuit replaces ad-hoc skill invocation and having to copy-paste or re-type the same instructions over and over (and over). Instead, just use /circuit:run or select a specific circuit. You can optionally provide a level of autonomy and rigor for more control.

Core Workflows:

These workflows are included and ready to use. You can create your own by following the guide in CUSTOM-CIRCUITS.md.

Workflow	Purpose
Explore	Investigate, understand, choose among options, shape a plan
Build	Features, refactors, docs, tests, mixed changes
Repair	Bugs, regressions, flaky behavior
Migrate	Framework swaps, dependency replacements, architecture transitions
Sweep	Cleanup, quality passes, coverage improvements

Rigor Levels:

Rigor	Budget
Lite	Plan and do.
Standard	Plan, do, independent review. One fix loop.
Deep	Research phase, seam proof. Workflows that include review still run it.
Tournament	Competing proposals, adversarial evaluation, convergence.
Autonomous	Checkpoints auto-resolve. Good for actually getting some sleep for once.

Every workflow follows these phases: Frame, Analyze, Plan, Act, Verify, Review, Close, Pause. Not every workflow goes through every phase, but the order remains consistent.

1. The router classifies your task. Circuit matches your task to a workflow and rigor profile. Quiet by default: it routes and proceeds unless something is genuinely ambiguous.

2. Steps run in the right order. Research before decisions. Decisions before implementation. Implementation gets an independent review from a separate session. Every step saves progress to disk.

3. Progress survives session clearing and crashes. Active run state (active-run.md) is updated after every phase. Session handoff state lives in ~/.claude/projects/ so fresh sessions resume where the last one stopped.

4. Stay in the loop. Circuit pauses at checkpoints to gather input (scope confirmation, tradeoff decisions). Everything else runs autonomously. Fully autonomous mode is also supported.

Commands

Using the router:

You type	What happens
/circuit:run <task>	Router picks the best workflow and rigor
/circuit:run fix: <bug>	Repair Lite -- test-first bug fix
/circuit:run repair: <issue>	Repair Deep -- broad investigation
/circuit:run develop: <feature>	Build Standard -- plan, implement, review
/circuit:run decide: <choice>	Explore Tournament -- adversarial evaluation
/circuit:run migrate: <target>	Migrate Deep -- inventory, coexistence plan, batches
/circuit:run cleanup: <target>	Sweep Standard -- cleanup by confidence/risk
/circuit:run overnight: <scope>	Sweep Autonomous -- unattended quality pass

Direct circuits:

You type	What happens
/circuit:explore	Investigation, decisions, planning
/circuit:build	Features, refactors, docs, tests
/circuit:repair	Bug fixes with regression contracts
/circuit:migrate	Migrations with coexistence planning
/circuit:sweep	Cleanup and quality sweeps
/circuit:review	Standalone fresh-context code review
/circuit:handoff	Save session state for the next session

See CIRCUITS.md for the full catalog with phase breakdowns and usage examples.

Key Features

Automatic workflow selection. Describe your task. Circuit picks the right workflow and rigor level.

Independent review. For Standard rigor and above, implementation and review run in separate sessions. The reviewer starts fresh with no knowledge of the implementation choices. Lite skips independent review where documented.