claude-dev-kit-sales

claude-kit (v0.1)

Turn a PRD into shipped code. 33 engineering agents + 23 skills (default install) handle the entire development lifecycle — from PRD to code review to deployment — so you can focus on what to build, not how. An optional sales pack (5 agents + 5 skills, opt-in via --pack=sales) covers account / discovery / proposal workflows for teams sharing a repo with engineering.

Why claude-kit?

Positioning: trustworthy code in collaboration → AI dev team control plane. The kit's bet is that AI productivity is bottlenecked not by the model but by what surrounds it — concurrency, state, guardrails, decision capture, learning. Adding more agents doesn't close that gap; structuring the work does.

Claude Code is powerful on its own, but without structure it produces inconsistent results — skipped tests, forgotten reviews, PRs that drift from requirements. claude-kit solves this by giving Claude Code a repeatable process:

• Structured pipeline: Every issue goes through spec (when required) → implement → review → ship. No shortcuts, no skipped phases.
• Specialized agents: Instead of one generalist prompt, 33 engineering agents each handle what they're best at — an architect designs the system, a reviewer audits security, a QA designer writes test plans, a design-auditor critiques the system, a separate ui-reviewer critiques the implementation.
• Decision capture: Non-trivial issues require a SPEC (/spec → docs/specs/SPEC-NNN.md) — Problem / Options ≥2 / Trade-offs / Decision / Rollback. Sprint mode auto-runs it; non-sprint mode HOLDs for review.
• Automatic feedback loops: Review findings create follow-up issues. Test failures trigger root-cause analysis. Shipped code gets test gap detection. Nothing falls through the cracks.
• Resumable state: Sprint progress is checkpointed to sprint_state.md. Crash or timeout? Just re-run /sprint to pick up where you left off.
• Zero configuration: Install as a git submodule, run one script, and all agents/skills/hooks are ready. Pack opt-in via a single flag.

In short: claude-kit turns Claude Code from a smart assistant into a development team that follows engineering best practices.

Overview

claude-kit takes a PRD (Product Requirements Document) as input and orchestrates AI agents to support the entire development lifecycle — from requirements analysis to code review and deployment.

Core Principles:

• GitHub-first: Issues and PRs are the single source of truth
• 1 Issue = 1 PR: Each issue maps to exactly one pull request
• issues.md as SSOT: Progress and completion are tracked by Status in this file
• Skill orchestration: Skills feed back into each other — review findings auto-create issues, shipped code triggers test gap detection, standalone skills register in the sprint ecosystem

Core Use Cases

1. Build a product from scratch

/prd → /kickoff → /uiux → /sprint
# (optional pre-PRD: /brainstorm → /bizanalysis → /prd)

Start with an idea, validate it, write a PRD, generate planning docs, design the UI, and let the team-lead auto-implement everything.

2. Implement a single feature

/implement ISSUE-001 → /review ISSUE-001 → /ship

Pick an issue from issues.md, implement it with TDD, review with security audit, and merge.

3. Run a full sprint

/sprint

Team-lead picks up all ready issues, implements them in parallel, reviews each PR, ships merged code, and auto-creates follow-up issues from review findings.

4. Fix a bug

/diagnose "TypeError in auth.py line 42" → /review → /ship

Trace the root cause, apply a minimal fix with regression test, review, and ship.

5. Improve test coverage

/testgen src/auth/

Scan for missing or hollow tests, generate unit/integration/E2E tests, and create a PR.

6. Analyze an existing codebase

/scan

Reverse-engineer docs from code: architecture, requirements, test plan, and improvement issues — then feed into /sprint or /implement.

7. Add a feature to an existing product

/issue "Add Stripe payment processing with subscription tiers, billing page, and invoice history"

Auto-detects that this spans multiple screens/modules, estimates issue count, updates planning and design docs incrementally (append-only), and creates a batch of implementation issues with dependencies.

8. Maintain and evolve

/refactor src/legacy_module.py    # Improve code structure
/migrate "Django 5.0"             # Upgrade dependencies
/devops "github-actions"          # Set up CI/CD

Workflow

New project:

/prd → /kickoff → /uiux → /sprint
# (optional pre-PRD: /brainstorm → /bizanalysis → /prd)