flywheel
v3.0.0
Skills-only · Claude Code + Droid

Plain-language wants in.
Verified PRs out.

Four skills turn what you ask for into a measurable goal queue. Agents claim each goal, build it in an isolated worktree, and merge only what passes a deterministic gate — autonomy you can actually leave running.

Install the plugin View source
4focused skills
0servers, hooks, or build
2CLIs, one install
the factory loop
# 1 · capture a want — define-goal does recon, then writes a contract
> I want first paint under 1.2s on the pricing page
define-goal ▸ recon (3 read-only agents) ▸ contract
✓ queued docs/goals/014-fast-pricing-fcp.md · type: feature

# 2 · let the factory work the queue, unattended
> /loop 15m /dispatch
dispatch ▸ 6/8 done ████████████████░░░░
running 2 · ready 0 · blocked 0
✓ merged goal 014 → main (gate: PASS)
How it works

From a sentence to a merged PR — on a loop.

The skills chain: capture wants as contracts, queue them in the repo, work the queue with isolated agents, and integrate verified merges — with a loop designed to run unattended.

01 · define-goal

Capture

Plain-language want → a measurable contract, grounded by recon. Queued into docs/goals/.

02 · the queue

Queue

Goal files + index.yaml live in the repo. Status lives only in the index, arbitrated by git push.

03 · dispatch

Work

Claims ready goals, spawns one isolated implementer per goal in its own worktree, shepherds the PR.

04 · integrate

Merge

Under merge: auto, a deterministic gate re-verifies on a fresh checkout, then the orchestrator merges.

The toolkit

Four skills that do one thing each, well.

They activate automatically when the conversation matches, or you invoke them directly. In Claude Code they're namespaced flywheel:<skill>.

define-goal

Turns a plain-language want — or a whole document of them — into a measurable goal contract, grounded by recon. Produces goals only; never implements.

/define-goal

dispatch

The factory orchestrator. Claims queued goals, spawns one isolated implementer per goal, and integrates verified merges through a deterministic gate. Orchestrates only.

/dispatch

loop-architect

Designs the loop contract — prompt + verification + stop conditions — so an unattended run actually converges and stops, instead of just “keep working on X”.

loop-architect

factory-doctor

One-pass preflight for a repo + machine: software, gh auth, merge allow-rule, branch protection, CI, queue state. Auto-fixes everything local; never merges.

/factory-doctor
The work queue

Goals live in the repo, not on a board.

No issue-body size limits, no per-repo label bootstrap — versioned with the code. PRs stay the review and merge surface.

docs/goals/ layout 
# status lives ONLY in index.yaml — goal files are immutable contracts
docs/goals/
├── index.yaml        # config + queue state
├── 001-faster-checkout.md
├── 002-fix-auth-redirect.md
└── done/            # archived completed goals
index.yaml · config block 
config:
  base: main            # branch goals fork from / merge back to
  state_branch: main    # where the queue lives (default = base)
  merge: auto           # pr = human merges · auto = factory merges
  wip: 2               # parallelism cap
  model: inherit        # inherit | sonnet | haiku
  validation: risk_based # off | risk_based | required

Invariants that keep it safe

Decided from real production runs, encoded so parallel sessions and unattended loops don’t corrupt the queue.

single sourceStatus lives only in index.yaml; dual-writing frontmatter drifts.
claim protocolpull → flip one entry → commit → push; push acceptance arbitrates parallel sessions.
isolationImplementers branch goal/<id> from origin/<base> and never touch docs/goals/.
blocked ≠ lostA blocked goal keeps a reason and is surfaced under needs-you, never re-dispatched into livelock.
auto-mergeOne goal at a time, sync-with-base then re-verify on a fresh checkout before every merge.
Get started

Install from the pragmatic-growth marketplace.

Same plugin, both CLIs — Droid auto-translates the .claude-plugin/ manifest, and the skills detect the runtime to use the right paths and commands.

add the marketplace & install 
/plugin marketplace add pragmaticgrowth/flywheel
/plugin install flywheel@pragmatic-growth
later, pull updates 
/plugin marketplace update pragmatic-growth
add the marketplace & install 
droid plugin marketplace add https://github.com/pragmaticgrowth/flywheel
droid plugin install flywheel@pragmatic-growth
later, pull updates 
droid plugin marketplace update pragmatic-growth
then — capture your first goal, preflight, and run the factory
/factory-doctor              # preflight the repo + machine
/define-goal I want the API p95 latency under 200ms
/loop 15m /dispatch          # work the queue, unattended