rsmdt/the-startup

Ship faster. Ship better. Ship with The Agentic Startup.

Table of Contents

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

🤖 What is The Agentic Startup?

The Agentic Startup is a spec-driven development framework for Claude Code. Create comprehensive specifications before coding, then execute with parallel specialist agents—Y Combinator energy meets engineering discipline.

Key Features:

• Native Claude Code Integration — Marketplace plugins with zero configuration
• Spec-Driven Development — PRD → SDD → Implementation Plan → Code
• Parallel Agent Execution — Multiple specialists work simultaneously
• Quality Gates — Built-in validation at every stage

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.

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

# Install the Start plugin (core workflows)
/plugin install start@the-startup

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

After installation:

# (Optional) Create project governance rules
/start: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
/start:specify Add user authentication with OAuth support

# Execute the implementation
/start: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 Commands at a Glance

┌──────────────────────────────────────────────────────────┐
│                    SETUP (optional)                      │
│                                                          │
│  /start:constitution ► Create project governance rules   │
│                        (auto-enforced in BUILD workflow) │
└──────────────────────────────────────────────────────────┘
                            │
                            ▼
┌──────────────────────────────────────────────────────────┐
│                    BUILD (primary flow)                  │
│                                                          │
│  /start:specify ────► Create specs (PRD + SDD + PLAN)    │
│        │               ↳ Constitution checked on SDD     │
│        ▼                                                 │
│  /start:validate ───► Check quality (3 Cs framework)     │
│        │               ↳ Constitution mode available     │
│        ▼                                                 │
│  /start:implement ──► Execute plan phase-by-phase        │
│        │               ↳ Constitution + drift enforced   │
│        ▼                                                 │
│  /start:review ─────► Multi-agent code review            │
│        │               ↳ Constitution compliance checked │
│        ▼                                                 │
│  /start:document ───► Generate/sync documentation        │
└──────────────────────────────────────────────────────────┘
                            │
                            ▼
┌──────────────────────────────────────────────────────────┐
│                    MAINTAIN (as needed)                  │
│                                                          │
│  /start:analyze ────► Discover patterns & rules          │
│                                                          │
│  /start:refactor ───► Improve code (preserve behavior)   │
│                                                          │
│  /start:debug ──────► Fix bugs (root cause analysis)     │
└──────────────────────────────────────────────────────────┘

Step-by-Step Walkthrough

Step 1: Create Your Specification

/start:specify Add real-time notification system with WebSocket support

This creates a specification directory with three documents:

docs/specs/001-notification-system/
├── product-requirements.md   # What to build and why
├── solution-design.md        # How to build it technically
└── implementation-plan.md    # Executable tasks and phases

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.

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
/start: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

/start: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

/start:implement 001

Claude will:

1. Parse the implementation plan
2. Execute phases sequentially (with your approval between phases)
3. Run tests after each task
4. Use parallel agents within phases for speed

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

Step 5: Review and Ship

/start: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 Command Should I Use?

Decision Tree

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

Command Reference

Capability Matrix