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
• **Consisten