Development
Plugin
claude-wave-plugin
Run Claude Code like an engineering org. Wave-based execution with dedicated sub-agents per phase, computed-style visual verification, no "tsc passes" lies.
Plugin Signal70/100Solid
maintained98
capable58
documented75
adopted24
Install on Claude Code
> /plugin marketplace add Harshvardhan86/claude-wave-plugin> /plugin install claude-wave-plugin@claude-wave-plugin
Stats
13
Stars
2
Forks
Active
Maintenance
Shell
Language
MIT
License
9d ago
Last commit
4mo ago
Created
Repo: Harshvardhan86/claude-wave-plugin
What's inside
Skill(6 skills)
/ac-writerUse as the first phase of a wave. Drafts brutal, testable acceptance criteria for a feature. Each AC must be falsifiable by a real-world test. Output written to .wave/ac.md./design-reviewerUse after AC and before RED for any wave that ships UI. Performs component API audit against installed dist files, produces per-route mockup, defines visual ACs, flags design-system gaps. Output written to .wave/dr.md./green-implUse after RED is verified failing. Writes the minimum code to make RED tests pass, then verifies on a live stack with Playwright screenshots before any hand-off. Implements the verify-before-scan rule.
Hook(7 hooks)
Command(2 commands)
/wave-checkpointSave wave state to disk so an auto-compact, session crash, or laptop battery death doesn't kill the run. Run this between phases or before any long operation./wave-startStart a new wave. Default runs the canonical v2 framework (17 phases + conditional [DR] for UI waves at 1.5 + optional [CR] gate at 3.5, max 19). Pass --demo for the trimmed 5-phase subset (AC → DR → RED → GREEN → TEET) for live demos and small UI features, or --solo for a
Badges
README
claude-wave-plugin
Run Claude Code like an engineering org. Wave-based execution with dedicated sub-agents per phase, computed-style visual verification, no "tsc passes" lies.
A real /wave-start run end-to-end: 17 phases dispatched through dedicated sub-agents, TDD-RED → GREEN → visual gates → cleanup → checkpoint. Unattended.
The defaults of "vibe-coding" optimise for time-to-first-demo. This plugin optimises for time-to-shippable.
Table of contents
- How is this different?
- Why this exists
- Prerequisites
- Install
- Quickstart — your first wave
- What you get
- Hook enforcement (v0.2.0)
- The 10 invariants
- The 5 hard-won rules
- Repository structure
- Community
- Listed on
- Used in production by
- Talks & writing
- Status
- Contributing
- License
How is this different?
| claude-wave-plugin | Superpowers | Vanilla Claude Code | |
|---|---|---|---|
| Workflow philosophy | Evidence-first verification | Brainstorm → plan → execute | One-shot prompts |
| Phases per feature | 17 base + 2 conditional | 7 stages | None |
| TDD enforcement | Hooks gate RED → GREEN order and evidence-file markers | Recommended | None |
| Visual verification gates | ✅ Computed-style assertions | ❌ | ❌ |
| Sub-agent isolation | ✅ Per-phase, lean context | ✅ | ❌ |
| Auto-compact recovery | ✅ Checkpoint resume | ❌ | ❌ |
| Best for | Production codebases where bugs cost money | Greenfield features, creative flow | Prototypes |
Both claude-wave-plugin and Superpowers are serious frameworks built by people shipping real code with Claude Code. They optimise for different problems. If you're brainstorming a new product feature, Superpowers' creative flow is excellent. If you're shipping into a production codebase where "the agent said it's done" is not acceptable evidence, this plugin is for you.
Why this exists
Most Claude Code workflows are one-shot: type a prompt, get a diff, ship it. That works for prototypes. It produces piles of fake-done features in production codebases — features whose tests pass but whose pages render blank, whose configs validate but whose runtime never reads them, whose data-theme="dark" attribute gets set on <html> while the screenshot stays light.
Wave-based execution treats Claude Code as an orchestration layer, not an autocomplete. Every phase of shipping a feature gets its own dedicated sub-agent with lean context — and the orchestrator gates each hand-off on real evidence (live stack screenshots, computed-style assertions, true end-to-end runs), not on "build clean".
This plugin packages that workflow.
Prerequisites
- Claude Code installed and authenticated. See the official docs.
- A project to run waves against (any language / stack).
- For hook enforcement: Bash, Git,
jq,flock,realpathand standard shell utilities. Missing hook prerequisites warn and allow; install them for the gates to operate. - For UI waves: a browser-driving setup such as Playwright. The framework's TEET phase uses Playwright via the official MCP.
- Optional but recommended: the CodeRabbit plugin if you want the
[CR]Code Review gate at Phase 3.5.
Install
# Add this repo as a plugin source
/plugins marketplace add https://github.com/Harshvardhan86/claude-wave-plugin
# Then install the plugin
/plugins install claude-wave-plugin
After installation you should see two new slash commands available:
/wave-start/wave-checkpoint
…and six skills registered: wave-orchestrator, ac-writer, design-reviewer, red-tests, green-impl, teet-verify.
Manual install (no marketplace)
If you'd rather install directly:
git clone https://github.com/Harshvardhan86/claude-wave-plugin.git \
~/.claude/plugins/local/claude-wave-plugin
Restart Claude Code. The plugin should be picked up automatically.
Quickstart — your first wave
In any project you want to ship a feature in:
/wave-start --demo "make the save button show a loading spinner"
What you'll see:
- The orchestrator dispatches the AC sub-agent.
.wave/ac.mdlands with brutal, testable criteria. - DR sub-agent audits your design system's installed dist files, writes a per-route mockup, defines computed-style visual ACs. Any design-system gap becomes an OPEN item that pauses the wave.
- RED writes failing tests against those ACs and prints the failure output. That's the point.
- GREEN writes the minimum code, starts the live stack, runs the full test suite, takes a Playwright screenshot.
- Visual approval gate. The orchestrator stops, shows you the screenshot, asks you to confirm before proceeding.
- TEET runs cross-system computed-style assertions and produces the final verdict.
If the agent says "done" without showing you a screenshot, refuse the hand-off — that's the failure mode the plugin exists to prevent.
Once you've shipped two or three waves with --demo successfully, drop the flag:
/wave-start "implement the new payment flow"
This invokes the canonical pipeline: 17 base phases plus [DR] (auto-engaged for UI waves) and optional [CR] (opt-in via cr_enabled). Brutal AC, Silent Error Analysis, Brutal SEA, Dependency Audit, Output Alignment, Brutalised E2E, version bump, commit, cleanup, checkpoint, dashboard — all dispatched as separate Agents with proper Opus / Sonnet / Haiku model routing.
If context fills before completion, /wave-checkpoint writes resume state to .wave/checkpoints/. A fresh session picks up exactly where you left off.
What you get
The full v2 framework (framework/)
This plugin vendors the complete Wave Execution Framework v2 — refined over months of production engineering work where bugs cost real money. 17 base phases plus two conditional gates: [DR] Design Review at Phase 1.5 (mandatory whenever the wave ships UI — web, mobile, Storybook, CLI-TUI) and [CR] Code Review at Phase 3.5 (optional, opt-in). Maximum surface per wave: 19 phases. Model-routed across Opus / Sonnet / Haiku, with hook-enforced invariants and worktree isolation for writing dispatches.
Demo on-ramps (skills/)
For first-time users, small features, and live-demo segments, the plugin ships five polished entry skills plus the orchestrator:
| Skill | Phase | Owns |
|---|---|---|
wave-orchestrator | Router | Full/demo dispatch and hand-off gates; solo mode for direct tasks |
ac-writer | 1. Acceptance Criteria | Brutal, testable ACs grounded in real visual vocabulary |
design-reviewer | UI: pre-RED gate (matches Phase 1.5) | Component API audit, per-route mockup, visual ACs |
red-tests | RED | Failing tests first, prove they fail before any code is written |
green-impl | GREEN | Minimum implementation, verify-before-scan: live stack + tests + screenshot |
teet-verify | TEET | True end-to-end with computed-style assertions, not toBeVisible() lies |
These run as /wave-start --demo "<feature>". The recommended starting point.
Commands (commands/)
/wave-start <feature>— runs the full v2 pipeline (17 base + conditional[DR]and[CR]gates)/wave-start --demo <feature>— runs the trimmed 5-phase entry subset/wave-start --solo <feature>— runs a direct task with explicit models, commit guard, PreCompact checkpoint and token ledger/wave-checkpoint— saves wave state to disk so an auto-compact (or laptop battery dying) doesn't kill the run
Hook enforcement (v0.2.0)
An active wave now has executable gates: phase order, valid phase/role/model, hand-off artifacts and markers, scope answers, design-review resolutions, UI screenshot approval and bug-fix strategy approval. Hooks keep the full/demo orchestrator focused on dispatch by gating tracked source edits, source reads, recognised build/test commands, nested dispatches and forks. Third phase/role rounds and output-token budget overruns require recorded approval.
Every main-session full/demo Agent dispatch starts its description with:
[W:<wave> P:<PHASE> R:<lead|executor|reviewer|scanner|writer>]
For example: [W:1 P:TDE-GREEN R:executor] implement AC-3. The tag is
case-sensitive, begins at byte 0 and has exactly one space between fields. The
first line of prompt is accepted as a fallback. Name model explicitly;
full/demo routing requires at least the tier in hooks/phases.tsv.
- Full applies the full phase table and all process gates. DR runs for UI or behaviour-changing waves; CR is conditional on its scope flag.
- Demo applies the same rules to
AC,DR,TDE-RED,TDE-GREEN,TEET. Skipped conditional or out-of-mode rows are looked through transitively so unfinished applicable predecessors cannot be bypassed. - Solo (
/wave-start --solo) keeps only the explicit-model rule, commit guard, PreCompact checkpoint, ledger and W-LEFTOVER inventory. No tag, prompt caps, phase order, tiers, orchestrator-only rules, rounds or budgets are enforced.
/wave-start creates .wave/state.json before dispatch and records full/demo
scope answers with scripts/wave-set.sh. The state defaults to enforce: "block".
Escape hatch: use --enforce warn when invoking scripts/wave-init.sh, or
set enforce to warn in the active .wave/state.json. Event-hook denials become
warnings with the same rule id and remedy. wave-set.sh changes scope flags only.
Close the wave with scripts/wave-close.sh when finished. With no active state,
plugin event hooks are silent; unreadable inputs and missing prerequisites warn
and allow.
Approvals, reports and checkpoints live under .wave/, excluded locally through
.git/info/exclude. Approval files record the user's decision; they are not
signatures or durable audit history. The commit guard checks staged planning
paths and message hygiene; .wave/approvals/commit-doc.md permits an intentional
planning-document exception. wave-init.sh also installs a Git commit-msg
guard when one is absent. That separate message guard remains active after a
wave closes and does not consult enforce.
The append-only .wave/ledger.jsonl records requested/resolved models and
input/output/cache tokens per agent, including failed hand-offs.
scripts/wave-scorecard.sh writes .wave/scorecard.md with spend, budget ratios,
File tree
FAQ
claude-wave-plugin is a Claude Code plugin with 6 hand-picked skills for development work, indexed on Flowy. Install it with the command on its page. It includes ac-writer, design-reviewer, green-impl. Its skills do not fire on their own yet. Request auto-invocation to have Flowy route them as you prompt. Free and open source.
- What is claude-wave-plugin?
- Run Claude Code like an engineering org. Wave-based execution with dedicated sub-agents per phase, computed-style visual verification, no "tsc passes" lies.
- How do I install claude-wave-plugin?
- Run these in Claude Code: /plugin marketplace add Harshvardhan86/claude-wave-plugin then /plugin install claude-wave-plugin@claude-wave-plugin. Then prompt normally.
- Does claude-wave-plugin auto-invoke its skills?
- Not yet. It is indexed on Flowy as a plain plugin. Request auto-invocation on its page and Flowy will route its skills for you as you prompt.
- Is claude-wave-plugin free?
- Yes. Flowy is free and open source, with nothing gated. You can read every skill in full before you install.
Is this plugin yours?
Claim it with GitHubSubmit a pluginPromote it