the-startup

---

Table of Contents

• 🤖 What is The Agentic Startup?
• 🚀 Quick Start
• 📖 The Complete Workflow
• 🎯 Which Skill Should I Use?
• 📦 Plugins
• 🎨 Output Styles
• 📊 Statusline
• 💡 Why The Agentic Startup?
• 🎯 Philosophy
• 📚 Documentation

---

New in v3: Agent Teams (experimental) — enable multi-agent collaboration where specialized agents coordinate and work together on complex tasks. The installer now offers to configure this automatically.

---

🤖 What is The Agentic Startup?

The Agentic Startup is a multi-agent AI framework that makes Claude Code work like a startup team. Create comprehensive specifications before coding, then execute with parallel specialist agents — expert developers, architects, and engineers working together to turn your ideas into shipped code.

10 slash commands across 3 phases. Specify first, then build with confidence.

Key Features:

• Spec-Driven Development — PRD → SDD → tier-appropriate decomposition → Code
• Three Decomposition Tiers — Direct, Incremental, Factory — /specify classifies complexity and /implement auto-dispatches
• Parallel Agent Execution — Multiple specialists work simultaneously
• Quality Gates — Built-in validation at every stage
• Zero Configuration — Marketplace plugins, one-line install

Installation

Requirements: Claude Code v2.0+ with marketplace support

curl -fsSL https://raw.githubusercontent.com/rsmdt/the-startup/main/install.sh | sh

This installs the core plugins, configures the default output style, and sets up the statusline with a customizable config file.

Start claude and run the following:

# Add The Agentic Startup marketplace
/plugin marketplace add rsmdt/the-startup

/plugin install start@the-startup  # Install the Start plugin (core workflows)
/plugin install team@the-startup   # (Optional) Install the Team plugin (specialized agents)

After installation:

# (Optional) Create project governance rules
/constitution                      # Auto-enforced during specify, implement, review

# Switch output styles anytime
/output-style "start:The Startup"   # High-energy, fast execution (default)
/output-style "start:The ScaleUp"   # Calm confidence, educational

---

🚀 Quick Start

Create a specification and implement it:

# Create a specification
/specify Add user authentication with OAuth support

# Execute the implementation
/implement 001

That's it! You're now using spec-driven development.

---

📖 The Complete Workflow

The Agentic Startup follows spec-driven development: comprehensive specifications before code, ensuring clarity and reducing rework.

All Skills at a Glance

┌──────────────────────────────────────────────────────────┐
│                    SETUP (optional)                      │
│                                                          │
│  /constitution ► Create project governance rules         │
│                  (auto-enforced in BUILD workflow)       │
└──────────────────────────────────────────────────────────┘
                            │
                            ▼
┌──────────────────────────────────────────────────────────┐
│                    BUILD (primary flow)                  │
│                                                          │
│  /specify ────► Create specs (Requirements + Solution)   │
│      │           ↳ Classifies complexity: Direct / Incremental / Factory │
│      │           ↳ Constitution checked on SDD           │
│      ▼                                                   │
│  /validate ───► Check quality (3 Cs framework)           │
│      │           ↳ Constitution mode available           │
│      ▼                                                   │
│  /implement ──► Auto-dispatch by tier, then execute      │
│      │           ↳ Direct (no plan) / Incremental (phase loop) / Factory (parallel units) │
│      │           ↳ Constitution + drift enforced         │
│      ▼                                                   │
│  /test ───────► Run tests, enforce ownership             │
│      │           ↳ No "pre-existing" excuses             │
│      ▼                                                   │
│  /review ─────► Multi-agent code review                  │
│      │           ↳ Constitution compliance checked       │
│      ▼                                                   │
│  /document ───► Generate/sync documentation              │
└──────────────────────────────────────────────────────────┘
                            │
                            ▼
┌──────────────────────────────────────────────────────────┐
│                    MAINTAIN (as needed)                  │
│                                                          │
│  /analyze ────► Discover patterns & rules                │
│                                                          │
│  /refactor ───► Improve code (preserve behavior)         │
│                                                          │
│  /debug ──────► Fix bugs (root cause analysis)           │
└──────────────────────────────────────────────────────────┘

Step-by-Step Walkthrough

Step 1: Create Your Specification

/specify Add real-time notification system with WebSocket support

This creates a specification directory with two foundational documents plus tier-specific decomposition artifacts:

.start/specs/001-notification-system/
├── requirements.md           # What to build and why  (always)
├── solution.md               # How to build it technically  (always)
│
│  # Then ONE of these, chosen by the complexity classifier:
│
├── (Direct tier)             # Fixes, refactors, single-AC features
│   └── no decomposition artifacts — implement reads requirements + solution directly
│
├── plan/                     # (Incremental tier) — single feature, 1–2 components
│   ├── README.md             #   Plan manifest
│   └── phase-N.md            #   Per-phase TDD tasks
│
└── manifest.md               # (Factory tier) — multi-feature, parallel work
    ├── units/                #   Atomic implementation specs
    │   └── *.md
    └── scenarios/            #   Holdout evaluation scenarios per unit
        └── {unit-id}/*.md

The spec cycle may take 15-30 minutes. Claude will research your codebase, ask clarifying questions, and produce comprehensive documents. The process naturally involves multiple back-and-forth exchanges.

Three Decomposition Tiers

/specify runs a complexity classifier at step 6 and recommends a tier. You can override the recommendation if you want a different level of ceremony.

Tier	When to use	Decomposition output	Implementation flow
Direct	Fixes, refactors, doc changes, single-AC features	none — requirements.md + solution.md only	implement-direct: lightweight 1–3 unit orchestration, drift check, no intermediate artifact
Incremental	Single feature with one or two components	plan/README.md + plan/phase-N.md (linear phase plan with TDD tasks)	implement-incremental: phase-by-phase loop with frontmatter status, human-in-the-loop review
Factory	Multi-feature, multi-component, parallel-eligible work	manifest.md + units/{id}.md + scenarios/{unit-id}/{name}.md	implement-factory: parallel unit dispatch with information barriers, holdout scenarios, and retry to a satisfaction threshold

You always invoke /specify and /implement — the sub-skills (specify-incremental, specify-factory, implement-direct, implement-incremental, implement-factory) are dispatched internally. /specify selects a decomposition sub-skill based on the chosen tier (Direct creates no extra artifact); /implement autodetects the tier by inspecting which artifacts exist.

Step 2: Handle Context Limits (Resume Pattern)

Large specifications may approach Claude's context window limits. When this happens:

# Start a new conversation and resume where you left off
/specify 001

The resume pattern:

• Pass the spec ID (e.g., 001) instead of a description
• Claude reads the existing spec files and continues from there
• You can reset context as many times as needed
• Each document (PRD → SDD → PLAN) can be completed in separate sessions if needed

Pro tip: If Claude suggests "you may want to reset context", do it! The quality of output improves with fresh context.

Step 3: Validate Before Implementation

/validate 001

This quality gate checks:

• Completeness - All sections filled, no missing details
• Consistency - No contradictions between documents
• Correctness - Requirements are testable and achievable

Validation is advisory—it provides recommendations but doesn't block you.

Step 4: Execute the Implementation

/implement 001

Claude will:

1. Autodetect the decomposition tier by inspecting the spec directory (plan/ → Incremental, manifest.md → Factory, neither → Direct)
2. Dispatch to the matching execution sub-skill (implement-direct, implement-incremental, or implement-factory)
3. Execute the work — phase-by-phase with approval gates (Incremental), parallel units with information barriers and holdout scenarios (Factory), or lightweight 1–3 unit orchestration (Direct)
4. Run tests after each task and use parallel specialist agents where the tier supports it

Large implementations may also need context resets. Simply run /implement 001 again in a fresh conversation—Claude tracks progress in the spec files.

Step 5: Review and Ship

/review

Four parallel specialists review your code:

• 🔒 Security - Authentication, authorization, input validation
• ⚡ Performance - Query optimization, memory management
• ✨ Quality - Code style, design patterns, maintainability
• 🧪 Tests - Coverage gaps, edge cases

---

🎯 Which Skill Should I Use?

Decision Tree

What do you need to do?
│
├─ Want project-wide guardrails? ─────────► /constitution
│
├─ Build something new? ──────────────────► /specify
│                                           Then: /validate → /implement
│
├─ Understand existing code? ─────────────► /analyze
│   └─ Want to improve it? ───────────────► Then: /refactor
│
├─ Something is broken? ──────────────────► /debug
│
├─ Need to run tests? ───────────────────► /test
│
├─ Code ready for merge? ─────────────────► /review
│
├─ Need documentation? ───────────────────► /document
│
└─ Check constitution compliance? ────────► /validate constitution

Skill Reference