Claude Kit

The development-workflow plugin for Claude Code. Opinionated skills and agents that teach Claude how to think, plan, review, and ship — so you don't spend your context window reinventing process.

Features

• 35 Skills organized around a 6-phase workflow: Think → Review → Build → Ship → Maintain → Setup
• 13 user-invocable spine skills — typed directly as /claudekit:<name>, the rest auto-trigger by context
• 24 Specialized Agents — planners, reviewers, implementers, and 4 plan-dimension reviewers
• Interactive Setup Wizard — /claudekit:init scaffolds rules, modes, hooks, and MCP configs
• 7 Behavioral Modes — task-specific response optimization (installed via init)
• MCP Integrations — Context7, Sequential Thinking, Playwright, Memory, Filesystem (configured via init)

Quick Start

Install via Marketplace

1. Add the claudekit marketplace:

   /plugin marketplace add duthaho/claudekit-marketplace
   

2. Install the plugin:

   /plugin install claudekit
   

3. Run the setup wizard to configure your project:

   /claudekit:init
   

   Or install everything at once:

   /claudekit:init --all
   

Local Development

Test the plugin locally without installing:

claude --plugin-dir ./path/to/claudekit

What /claudekit:init Configures

The setup wizard interactively scaffolds project-level configuration:

Category	What	Location
Rules	API, frontend, migrations, security, testing	.claude/rules/
Modes	brainstorm, deep-research, default, implementation, orchestration, review, token-efficient	.claude/modes/
Hooks	auto-format, block-dangerous-commands, notifications	.claude/hooks/ + settings.local.json
MCP Servers	Context7, Sequential, Playwright, Memory, Filesystem	.mcp.json

Plugin Structure

claudekit/
├── .claude-plugin/
│   └── plugin.json            # Plugin manifest
├── skills/                    # 35 skills (auto-triggered; 13 user-invocable)
│   ├── init/                  # Setup wizard (/claudekit:init)
│   │   ├── SKILL.md
│   │   └── templates/         # Rules, modes, hooks, MCP templates
│   ├── brainstorming/
│   ├── systematic-debugging/
│   └── ...
├── agents/                    # 24 specialized agents
├── scripts/                   # Hook scripts (installed via init)
└── website/                   # Documentation site

Agents

Core Development

Agent	Description
claudekit:planner	Task decomposition and planning
claudekit:debugger	Error analysis and fixing
claudekit:tester	Test generation
claudekit:code-reviewer	Code review with security focus
claudekit:scout	Codebase exploration

Operations

Agent	Description
claudekit:git-manager	Git operations and PRs
claudekit:docs-manager	Documentation generation
claudekit:project-manager	Progress tracking
claudekit:database-admin	Schema and migrations
claudekit:ui-ux-designer	UI component creation

Content & Research

Agent	Description
claudekit:researcher	Technology research
claudekit:scout-external	External resource exploration
claudekit:copywriter	Marketing copy and release notes
claudekit:journal-writer	Development journals and decision logs

Extended

Agent	Description
claudekit:cicd-manager	CI/CD pipeline management
claudekit:security-auditor	Security reviews
claudekit:api-designer	API design and OpenAPI
claudekit:vulnerability-scanner	Security scanning
claudekit:pipeline-architect	Pipeline optimization

Plan Review

Agent	Description
claudekit:ceo-reviewer	Strategic/scope review of a written plan (ambition, problem clarity, wedge focus, demand reality, future-fit)
claudekit:eng-reviewer	Architecture review (data flow, failure modes, edge cases, test matrix, rollback)
claudekit:design-reviewer	UX/visual plan review (hierarchy, consistency, states, accessibility, AI-slop avoidance)
claudekit:devex-reviewer	Developer-experience review (TTHW, ergonomics, error copy, docs structure, magical moments)

Skills

Claude Kit is organized around a 6-phase development workflow. Each phase has a small set of spine skills you invoke directly (/claudekit:<name>); supporting skills auto-trigger behind the scenes when relevant.

🧠 Think — explore ideas, produce a spec

Skill	Description
brainstorming	Interactive idea exploration, one question at a time. Includes Startup Mode (6 forcing questions) for new product ideas
writing-plans	Break a spec into bite-sized tasks with exact code, file paths, and test commands

🔍 Review — pressure-test the plan before coding

Skill	Description
autoplan	Run all 4 plan-review dimensions in parallel, consolidate into one fix gate
plan-ceo-review	Strategy review — ambition, problem clarity, wedge focus, demand reality, future-fit
plan-eng-review	Architecture review — data flow, failure modes, edge cases, test matrix, rollback
plan-design-review	UX review — information hierarchy, visual consistency, state coverage, accessibility
plan-devex-review	Developer experience review — TTHW, API/CLI ergonomics, error copy, docs, magical moments

Each plan-review skill dispatches a dimension-specific reviewer agent, scores 0-10 on 5 sub-dimensions, proposes concrete fixes, and applies user-selected fixes to the plan.

🔨 Build — implement with discipline

Skill	Description
feature-workflow	End-to-end orchestrator: requirements → plan → review → implement → test → review
test-driven-development	Red-green-refactor cycle — no production code without a failing test first
systematic-debugging	4-phase root-cause investigation — gather, hypothesize, test, prove
verification-before-completion	Mandatory pre-completion gate — evidence before assertions

🎛️ Session & Setup

Skill	Description
mode-switching	Switch behavioral modes (brainstorm, token-efficient, deep-research, implementation, review)
init	Interactive wizard — scaffolds rules, modes, hooks, and MCP configs into your project

Also Included — 22 supporting skills (auto-trigger, non-user-invocable)

These activate silently when Claude detects a matching context. You don't invoke them directly, but they shape how Claude works.

Category	Skills
Execution & Parallelism	executing-plans, subagent-driven-development, using-git-worktrees, finishing-a-development-branch, dispatching-parallel-agents, condition-based-waiting
Testing Discipline	testing, playwright, testing-anti-patterns
Debug Techniques	root-cause-tracing, defense-in-depth
Review Etiquette	requesting-code-review, receiving-code-review
Reasoning & Meta	sequential-thinking, writing-concisely, writing-skills, refactoring
Operations	devops, git-workflows, performance-optimization, session-management
Security	owasp

Bundled Resources

Spine and supporting skills include progressive-disclosure resources loaded on demand:

Resource Type	Purpose
references/	Cheat sheets, decision trees, pattern catalogs
templates/	Starter files, boilerplate, configs
scripts/	Executable helpers for deterministic tasks

Behavioral Modes

Installed via /claudekit:init. Switch modes to optimize responses:

Mode	Description	Best For
default	Balanced standard behavior	General tasks
brainstorm	Creative exploration, questions	Design, ideation
token-efficient	Compressed, concise output	Cost savings
deep-research	Thorough analysis, citations	Investigation
implementation	Code-focused, minimal prose	Executing plans
review	Critical analysis, finding issues	Code review
orchestration	Multi-task coordination	Parallel work

"switch to brainstorm mode"     # -> mode-switching skill activates
"let's focus on implementation" # -> implementation mode

MCP Integrations

Configured via /claudekit:init. MCP servers extend Claude Kit with powerful capabilities.

Server	Package	Purpose
Context7	@upstash/context7-mcp	Up-to-date library documentation
Sequential	@modelcontextprotocol/server-sequential-thinking	Multi-step reasoning
Playwright	@playwright/mcp	Browser automation (Microsoft)
Memory	@modelcontextprotocol/server-memory	Persistent knowledge graph
Filesystem	@modelcontextprotocol/server-filesystem	Secure file operations

Workflow Chains

Skills chain automatically based on context:

Feature Development

brainstorming -> writing-plans -> autoplan -> feature-workflow -> requesting-code-review -> git-workflows

autoplan pressure-tests the plan on strategy, architecture, design, and DX before implementation begins — optional but recommended for non-trivial features.

Bug Fix

systematic-debugging -> root-cause-tracing -> test-driven-development -> verification-before-completion

Ship Code

verification-before-completion -> requesting-code-review -> git-workflows -> finishing-a-development-branch

Parallel Work

dispatching-parallel-agents -> subagent-driven-development -> verification-before-completion

Requirements

• Claude Code 1.0+
• Git
• Node.js or Python (depending on your stack)

License

MIT

---

Built by duthaho