figma

claude-dev-kit

An open-source Claude Code plugin by The Agile Monkeys: a stack-agnostic issue-to-PR workflow with enforced quality gates. Also runs on OpenAI Codex, Cursor, and other Agent Plugins 1.0.0 clients.

Demo

The kit taking a ticket all the way to an opened PR (test project yardflow):

https://github.com/user-attachments/assets/21afb5ab-b52b-4418-bf01-d247e8d73208

What it does

The issue-to-PR flow

Give the coding-agent a user story ID from your tracker and it orchestrates the whole flow:

/work-story PROJ-1234
   │
   ├─ issue-fetch         → ticket summary + acceptance criteria + comments
   ├─ figma-fetch         → design context (if the ticket links Figma)
   ├─ PLAN + user approval (mandatory gate)
   ├─ implement           → follows the consuming repo's conventions & subagents
   ├─ coverage-check      → touched files meet the project's bar (default ≥ 95%)
   ├─ e2e-generate        → e2e tests (repo's framework) incl. edge cases
   ├─ security-reviewer   → authorization / secrets / input / exposure pass (gate)
   ├─ pr-review → pr-fixer → self-review, then fix the blocking findings
   ├─ create-pr           → branch + commit + PR with verification evidence
   ├─ issue-update        → comment PR link on the ticket + move it to review
   └─ follow-ups          → offer to track leftover loose ends as linked tickets

From idea to backlog (product owners)

Before there's a ticket, plan-backlog turns an idea or brief — chat text, a PDF, a Word doc, an artifact — into a well-formed backlog (epics, INVEST user stories with acceptance criteria, sub-tasks, dependencies) and creates it in your tracker after you approve it. It's discovery-first (mirrors your team's existing hierarchy and conventions rather than imposing one) and speaks Jira / Linear / GitHub Issues / Azure DevOps via the same adapters. The stories it creates feed straight into /work-story — closing the loop idea → backlog → ticket → PR.

It's guided by default — it elaborates progressively (framing → epics → stories), offering alternatives and asking for your decision at each level, so the definition stays yours; add --quick for a one-shot draft. On Claude, a non-trivial backlog is shown as a navigable artifact for review (approval still happens in the chat). In Claude Code, run /plan-backlog <idea | path/to/brief.pdf | URL> [--quick]. On Codex / Cursor / Copilot, invoke the plan-backlog skill directly.

Even earlier — defining the problem. When the idea is still a rough spark, plan-definition runs the discovery phase before the backlog: a guided, Socratic pass that frames the problem (users, outcome, why-now, constraints, success metrics, non-goals), explores 2–4 directions with trade-offs, and produces an approved product definition — a definition doc, not tickets. That definition then feeds plan-backlog, whose framing is lighter because the problem is already defined. Run /plan-definition <idea | brief> (or invoke the plan-definition skill). It facilitates your thinking; it never decides the product for you.

Quality gates

Always apply (regardless of stack or test setup):

• No code before the plan is approved (unless --auto-approve for pipelines).
• Security pass (security-reviewer) with no blocking findings.
• PR body carries the verification evidence; the ticket gets the PR link and moves to review.

Adaptive — enforce the project's own standard, detected each run (the kit never imposes tests or scaffolds a framework on a project that doesn't use one):

• If the project has tests/coverage: touched files meet its bar (default ≥ 95%) and don't regress; suites pass; lint clean.
• User-facing changes get e2e when the project already does e2e.
• No test/e2e/lint setup → the kit recommends it and says so in the PR — it doesn't block. Teams wanting a hard bar set a gates policy (auto (default) · required · off) in .claude/dev-kit.json.
• Accessibility (frontend only): when a change touches user-facing UI in a frontend stack, the review automatically covers the a11y basics (alt text, labels, accessible names, keyboard/focus, contrast, correct ARIA) — using the repo's own a11y tooling if it has any, never scaffolding one. It's automatic and non-blocking by default, costs nothing on backend/non-UI changes, and needs no setup. To change it, set "a11y" in .claude/dev-kit.json to auto (default) · required (make it a blocking gate) · off (never run) — edit it by hand, or just ask the kit to do it (e.g. "make accessibility a required gate") and it updates the file for you.

Either way, a skipped gate is reported, never hidden.

Stack-agnostic by design

The kit carries no assumptions about language, framework, or test runner. It reads everything stack-specific — build/test/lint/coverage commands, architecture conventions, and any implementer subagents — from the consuming repo's instructions file (CLAUDE.md, or AGENTS.md on Codex) and .claude/, and detects conventions from the project when they aren't declared.

It ships baseline "iteration zero" profiles for common stacks in instructions/stacks/ — node, angular, react, vue, python, dotnet, java, go, ruby, php, rust — giving each one usable coverage/e2e/lint commands out of the box. These travel with the plugin, so they work the same on every host. Your project's instructions file always overrides them (CLAUDE.md on Claude, AGENTS.md on Codex, .github/copilot-instructions.md on Copilot), and adding a stack is one markdown file (see CONTRIBUTING). These profiles are early and community-refined — treat an unlisted or unverified stack as "should work, help us confirm" rather than guaranteed.

It integrates with your tools through adapters, not hardcoded dependencies:

Getting started

Installation

The kit is a Claude Code plugin (and an Agent Plugins 1.0.0 plugin for other clients). Install it once per developer; it then loads in every session across every surface — the CLI, the desktop app, the VS Code / JetBrains extensions, and the web app (claude.ai/code).

Prerequisites: Claude Code (claude --version) and the GitHub CLI authenticated (gh auth status).

Recommended: the setup wizard

npm create @theagilemonkeys/dev-kit

Interactive setup — tracker, Figma, telemetry consent, org — then it installs the plugin for whichever agents you have (Claude Code / Codex / Cursor). The wizard picks your issue tracker and whether you use Figma, shows exactly what anonymous telemetry would be collected and lets you opt in or out, sets your organisation label, writes .claude/dev-kit.json, and runs the plugin install for you. Then authorize your connectors (below) and you're done.

Or install directly on your host

Per-host details and caveats follow.

Claude Code

Manual install (what the wizard automates) — from a terminal (plugin management is CLI-only; the VS Code / JetBrains chat panels reject /plugin commands):

claude plugin marketplace add theam/claude-dev-kit
claude plugin install fullstack-dev-kit@claude-dev-kit

Installation is user-level and permanent — every future session (CLI or IDE extension) loads the kit automatically, no reinstall per session or project. Verify with claude plugin list, or type / in a session and search fullstack-dev-kit: (you should see work-story, launch-story, and the skills; agents show under /agents).

Enable auto-update: /plugin → Marketplaces tab → claude-dev-kit → Enable auto-update. New versions then arrive at session startup. To pull manually instead:

claude plugin marketplace update claude-dev-kit

Team-wide install (optional — one config for everyone). Instead of each developer running the two install commands, a consuming repo can commit the marketplace + plugin to its own .claude/settings.json. Teammates then get the kit when they open and trust the repo — in the CLI and the Desktop app's Code tab alike:

{
  "extraKnownMarketplaces": {
    "claude-dev-kit": {
      "source": { "source": "github", "repo": "theam/claude-dev-kit" }
    }
  },
  "enabledPlugins": {
    "fullstack-dev-kit@claude-dev-kit": true
  }
}

Pin to a release by adding "ref": "v0.5.0" (or a "sha") to source; omit it to always track the default branch. Requires the marketplace repo to be public (or teammates to have git access to it).

Heads-up: auto-load on folder-trust is the intended behavior, but a known Claude Code issue (#32606) means some setups still need a one-time manual claude plugin install fullstack-dev-kit@claude-dev-kit. Test with one teammate before rolling out to everyone.

OpenAI Codex

Validated on codex-cli 0.147.

codex plugin marketplace add theam/claude-dev-kit
codex plugin add fullstack-dev-kit@claude-dev-kit

Then invoke $work-story PROJ-1234 (or any single skill like $pr-review). The npm create wizard also installs the connector your tracker implies (Jira → atlassian-rovo, Linear → linear, Figma → figma; GitHub/Azure use their CLIs) and schedules the telemetry sweep. Details: codex/README.md.

GitHub Copilot (VS Code)

Experimental in VS Code. Command Palette → "Chat: Install Plugin From Source" → paste https://github.com/theam/claude-dev-kit. VS Code clones and installs it; skills load from the plugin's skills/ and any mcp.json starts automatically. Add your tracker's MCP via MCP: Add Server (or .vscode/mcp.json). Feature is labeled Experimental — behavior may shift.

Cursor