compote

Claude Code plugins for a spec-driven development loop: write a plan and execute it task by task, review a branch or a pull request with focused reviewer agents, and close the two open ends of that loop — reading a design into a spec, and verifying a change in the running application.

Plugins

• plan-flow — writes implementation plans with a frozen intent, a tested edge-case matrix and an annotated code map, then executes them task by task, each in a context scoped to that one task. Ships working agreements for how code is written, delivered through a one-line import you add to ~/.claude/CLAUDE.md by hand.
• review-flow — review of a GitHub pull request or the current branch, plus an author-side pass that fixes and answers the feedback you received. Dispatches focused reviewer agents matched to the diff, verifies every finding against the source before it is reported, and publishes an approved subset as inline PR comments. Requires the GitHub CLI (gh), authenticated.
• pr-tickets — triages the findings a review deliberately left unposted (pre-existing problems and deferred work) and turns the ones worth tracking into Jira issues, after verifying each against the base branch. Requires review-flow, Atlassian's twg CLI (logged in), and a .claude/pr-tickets.json in the consuming repository.
• dependabot-triage — triages a repository's open Dependabot PRs: categorizes each by risk against how the repository actually uses the dependency, merges the safe ones after approval, and closes the unwanted ones so they aren't proposed again. Requires gh.
• rn-performance-reviewer — a React Native performance reviewer for review-flow. Reports statically-provable defects in lists, effects and subscriptions, animations, Skia usage, memoization, bundle size and image rendering, and never speculative optimization advice.
• figma-flow — reads a Figma node and returns a compact spec in the project's own code vocabulary — tokens, components and icons from the project's design-mapping document — instead of dumping raw design-tool output into the caller's context. Also downloads and verifies image and vector assets. Needs the Figma plugin and a .claude/docs/figma-mapping.md in the consuming repository.
• ui-verifier-mobile — verifies UI changes in a running React Native app against a caller-supplied checklist: drives the simulator or emulator with agent-device, measures what it sees, captures screenshots, and returns a pass/fail report with evidence. Never modifies code.
• ui-verifier-web — the same for a web app or browser extension, driving the browser with agent-browser.

Both verifiers read a .claude/docs/ui-verification.md in the consuming repository for that project's own facts — bundle ids, build and launch commands, auth routes, app traps — and say so at the top of the report when it is absent.

Installing

claude plugin marketplace add Comp0te/claude-plugins

claude plugin install plan-flow@compote --scope user
claude plugin install review-flow@compote --scope user
claude plugin install pr-tickets@compote --scope user   # optional; needs the twg CLI
claude plugin install dependabot-triage@compote --scope user   # optional

plan-flow then needs one line added to ~/.claude/CLAUDE.md — see its README.

Install the rest per repository, from inside it. At user scope the performance reviewer would join the reviewer roster of every project, and both verifiers would load everywhere:

cd <a React Native repository>
claude plugin install rn-performance-reviewer@compote --scope project
claude plugin install ui-verifier-mobile@compote --scope project
claude plugin install figma-flow@compote --scope project

cd <a web repository>
claude plugin install ui-verifier-web@compote --scope project

Command names

Commands and skills resolve under their plugin's prefix, and only under it:

/plan-flow:execute-plan
/review-flow:pr-review     /review-flow:branch-review
/review-flow:pr-publish    /review-flow:pr-recheck
/review-flow:address-review
/pr-tickets:jira
/dependabot-triage:dependabot-triage

Updating

claude plugin marketplace update compote
claude plugin update <name>@compote --scope user

For a project-scope install, run the update from inside that repository with --scope project; each such install is updated separately. Restart the session to pick up the new version.

What changed in each version is in the repository's Releases.

Developing

Installing copies a plugin into ~/.claude/plugins/cache/compote/<name>/<version>/, and that cache is keyed by version: an edit without a version bump never reaches an installed session. Raise version in the plugin's plugin.json and in its marketplace.json entry whenever its content changes.

If the bump changes a skill, agent, command, hook or the working agreements of plan-flow or review-flow, run the evals it affects first and tag only when they pass:

python3 scripts/run-evals.py --plugin <name>

It diffs against the plugin's last release tag, shows what it will run and roughly what it costs, runs it, and exits non-zero on a regression or a run that could not finish.

To release a bump, push it, then tag it and publish its notes:

claude plugin tag plugins/<name> --push        # creates <name>--v<version>
gh release create <name>--v<version> --title "<name> <version>" --notes "<what changed, what to do>"

Installs pick the new version up through claude plugin update; the release is where a user reads what changed.

To work against a local clone, add it as the marketplace instead of the GitHub repository: claude plugin marketplace add <path to your clone>.

Text shared between commands and agents lives in shared/ and is copied between <!-- shared:NAME --> markers by scripts/sync-shared.py (shared/blocks.json maps each block to its targets). Edit the source in shared/, never the copy, then run the sync.

CI (.github/workflows/checks.yml) runs every check that costs nothing — the shared-block sync, the structure and hunk-map checkers, every unit-test suite, claude plugin validate on the marketplace and each plugin, and claude plugin test for plan-flow's progress pane. The workflow is the list of commands to run locally before a push. tsc -p plugins/plan-flow stays local: it needs declaration files that Claude Code writes only when a session loads the plugin.

The model-graded evals and their costs are described in plugins/plan-flow/evals/README.md and tests/review-flow/reviewer-evals/README.md.

Incident → eval

An incident is a plugin behaviour someone had to correct, a review finding the gate refuted or the author rejected with a reason, or a measured regression. The change that fixes it also adds a case reproducing it — a plan-flow eval case or a reviewer-eval case, whichever harness covers the component; a unit test when the behaviour is deterministic; and, for a plugin with no eval harness, an entry in that plugin's TODO.md naming the incident. The case's README row cites where the incident was seen: session id and timestamp, or review handoff and finding id.

License

MIT