Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Claude Wave Plugin: Evidence-First Engineering Waves

    1

    Run Claude Code like an engineering org: a dedicated sub-agent per phase, strict TDD, visual verification gates and hook-enforced phase order.

    Free

    1 useSecurity scanned
    Claude Wave Plugin: Evidence-First Engineering Waves

    Claude Wave Plugin: Evidence-First Engineering Waves

    Example session with this skill installed

    /wave-start --demo "make the save button show a loading spinner"

    • Read your context and instructions
    • Compiled the claude wave plugin

    Summary

    The orchestrator runs the 5-phase demo wave (AC, DR, RED, GREEN, TEET). Each phase is a separate sub-agent with lean context, and every hand-off is gated on evidence files under .wave/.

    What happens, phase by phase

    #PhaseSub-agentEvidence produced
    1Acceptance Criteriaac-writer.wave/ac.md: brutal, falsifiable ACs (spinner visible while saving, button disabled, spinner gone on success/error)
    2Design Reviewdesign-reviewer.wave/dr.md: audit of your design system's installed dist files, per-route mockup, computed-style visual ACs. Any design-system gap becomes an OPEN item that pauses the wave
    3REDred-testsFailing tests written against the ACs, with the failure output printed as proof
    4GREENgreen-implMinimum implementation, live stack started, full test suite run, Playwright screenshot taken
    5Visual approvalorchestratorThe wave stops, shows you the screenshot and asks you to confirm before going on
    6TEETteet-verifyCross-system computed-style and boundingBox assertions, plus the final verdict

    Example of a visual AC it enforces

    // Not toBeVisible(): that passes for a 0x0 element
    const box = await spinner.boundingBox();
    expect(box.width).toBeGreaterThan(0);
    expect(await spinner.evaluate(e => getComputedStyle(e).animationName)).not.toBe('none');
    

    The rule to remember

    If the agent says "done" without showing you a screenshot, refuse the hand-off. That is exactly the failure mode the plugin exists to prevent.

    Next steps

    • After two or three successful --demo waves, drop the flag: /wave-start "implement the new payment flow" runs the full 17-phase pipeline with [DR] and optional [CR].
    • If context fills mid-wave, run /wave-checkpoint and resume in a fresh session.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Stop vibe-coding. claude-wave-plugin turns Claude Code into an orchestration layer instead of an autocomplete. Every phase of shipping a feature gets its own dedicated sub-agent with lean context, and the orchestrator only accepts a hand-off when it sees real evidence: live-stack screenshots, computed-style assertions and true end-to-end runs. "Build clean" or "tsc passes" is never enough.

    The defaults of vibe-coding optimise for time-to-first-demo. This plugin optimises for time-to-shippable.

    The problem it solves

    One-shot prompting produces fake-done features in production codebases: tests that pass while the page renders blank, configs that validate but are never read at runtime, a data-theme="dark" attribute that is set while the screenshot stays light. Wave execution makes those failures impossible to hand off.

    What you get

    • Full Wave Execution Framework v2: 17 base phases plus two conditional gates, [DR] Design Review (mandatory for UI waves) and [CR] Code Review (opt-in). Brutal ACs, Silent Error Analysis, Dependency Audit, Brutalised E2E, version bump, commit, cleanup, checkpoint.
    • Model routing: Opus advises (plan, critique, decide), Sonnet executes (code, tests, scans), Haiku handles mechanical steps.
    • Hook enforcement (v0.2.x): phase order, valid phase/role/model, hand-off artifacts and markers, UI screenshot approval and bug-fix strategy approval are gated by executable hooks, not by trust.
    • Checkpoint resume: /wave-checkpoint (and an automatic PreCompact checkpoint) writes resume state to .wave/checkpoints/, so auto-compact or a dead battery never kills a run.
    • Token ledger and scorecard: per-agent model and token accounting, budgets and rework tracking.

    Skills included

    SkillPhaseOwns
    wave-orchestratorRouterFull/demo/solo dispatch and hand-off gates
    ac-writer1. Acceptance CriteriaBrutal, falsifiable ACs
    design-reviewer1.5 Design ReviewComponent API audit against installed dist files, per-route mockup, visual ACs
    red-testsREDFailing tests first, proven to fail
    green-implGREENMinimum code, then live stack + full tests + screenshot
    teet-verifyTEETTrue end-to-end with computed-style and boundingBox assertions
    wave-execution-framework-v2Canonical specThe 17-phase pipeline, 10 invariants and 12 reference docs

    Commands

    • /wave-start "<feature>": full v2 pipeline
    • /wave-start --demo "<feature>": trimmed 5-phase entry subset (AC, DR, RED, GREEN, TEET). Start here.
    • /wave-start --solo "<feature>": direct task with explicit models, commit guard, checkpoint and ledger
    • /wave-checkpoint: save wave state to disk

    The 5 hard-won rules

    1. Verify before scan: never scan un-verified GREEN.
    2. Visual effect over DOM presence: toBeVisible() is true for a 0x0 element, so assert computed styles and bounding boxes.
    3. Visual vocabulary grounding: never invent a colour or token the app does not already render.
    4. Never implement without wiring: trace config to runner to handler end-to-end.
    5. Permissions once, upfront.

    Best for

    Production codebases where bugs cost money and "the agent said it's done" is not acceptable evidence. For quick prototypes or one-line fixes, plain prompting is faster.

    Open source (MIT): https://github.com/Harshvardhan86/claude-wave-plugin

    Requires local test infrastructure and live stack for verification. Not for single-file edits or research-only tasks. Effective only for projects with 3+ vertical slices of value.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Requires

    Claude Code
    Bash
    Git
    jq
    flock
    realpath
    Playwright MCP
    Node.js
    vitest

    Permissions

    Terminal / Shell
    Browser
    Network Access
    Read Files
    Write Files

    File Scopes

    .wave/**

    Shell: hooks are Bash scripts that gate phase order, and phases run your build/test commands. Read/Write: sub-agents write code and tests in your repo, and wave state, approvals, checkpoints and the token ledger live under .wave/ (excluded from git). Browser: Playwright drives the live stack for screenshots and computed-style assertions in UI waves. Network: only for your own project's dependency installs and local dev server. The plugin itself sends no data anywhere.

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    In Claude Code run: /plugins marketplace add https://github.com/Harshvardhan86/claude-wave-plugin, then /plugins install claude-wave-plugin. Start with /wave-start --demo "<feature>" for your first few waves.

    The skill is built for Claude Code and Agent SDK environments. It leverages model routing to dispatch specific tasks to Opus, Sonnet, or Haiku, so you will need an active API configuration that supports these models.

    Claude Code, plus Bash, Git, jq, flock and realpath for hook enforcement (if any are missing, hooks warn and allow instead of blocking). For UI waves you need a browser-driving setup such as the official Playwright MCP. The CodeRabbit plugin is optional and only used for the [CR] Code Review gate. Works with any language or stack.

    Yes, it is free and MIT-licensed. You get the full Wave Execution Framework v2 (17 base phases plus [DR] and [CR] gates, 12 reference docs), 6 phase skills (wave-orchestrator, ac-writer, design-reviewer, red-tests, green-impl, teet-verify), the /wave-start and /wave-checkpoint commands, and the hook scripts that enforce phase order, hand-off evidence and model routing. Source: https://github.com/Harshvardhan86/claude-wave-plugin

    This skill is designed for high-stakes production features and complex migrations where zero-regression is mandatory. It is not recommended for rapid prototyping or simple one-file fixes, as the high-rigor quality gates are optimized for integrity over raw speed.

    In Claude Code run: /plugins marketplace add https://github.com/Harshvardhan86/claude-wave-plugin then /plugins install claude-wave-plugin. Start with /wave-start --demo "<feature>" for your first few waves.

    New in Agents & Orchestration