drift-detection

• [🤖 What is The Agentic Startup?](#-what-is-the-agentic-startup)
• [🚀 Quick Start](#-quick-start)
• [📖 The Complete Workflow](#-the-complete-workflow)
• [🎯 Which Command Should I Use?](#-which-command-should-i-use)
• [📦 Plugins](#-plugins)
• [🎨 Output Styles](#-output-styles)
• [📊 Statusline](#-statusline)
• [🎯 Philosophy](#-philosophy)
• [📚 Documentation](#-documentation)

---

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

```bash

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](#-statusline) with a customizable config file.

After installation:

```bash

# (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

```

---

Create a specification and implement it:

```bash

# 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 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

```bash

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

```bash

# 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

```bash

/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

```bash

/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

```bash

/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

---

Decision Tree

```

What do yo