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

• 🤖 What is The Agentic Startup?
• 🚀 Quick Start
• 📖 The Complete Workflow
• 🎯 Which Command Should I Use?
• 📦 Plugins
• 🎨 Output Styles
• 🎯 Philosophy
• 📚 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

Requirements: Claude Code v2.0+ with marketplace support

# 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

# Initialize your environment (statusline)
/start:init

# Choose your output style
/output-style start:The Startup    # High-energy, fast execution
/output-style start:The ScaleUp    # Calm confidence, educational

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 Agentic Startup follows spec-driven development: comprehensive specifications before code, ensuring clarity and reducing rework.

┌──────────────────────────────────────────────────────────┐
│                    SETUP (one-time)                      │
│                                                          │
│  /start:init ───────► Configure statusline & environment │
└──────────────────────────────────────────────────────────┘
                            │
                            ▼
┌──────────────────────────────────────────────────────────┐
│                    BUILD (primary flow)                  │
│                                                          │
│  /start:specify ────► Create specs (PRD + SDD + PLAN)    │
│        │                                                 │
│        ▼                                                 │
│  /start:validate ───► Check quality (3 Cs framework)     │
│        │                                                 │
│        ▼                                                 │
│  /start:implement ──► Execute plan phase-by-phase        │
│        │                                                 │
│        ▼                                                 │
│  /start:review ─────► Multi-agent code review            │
│        │                                                 │
│        ▼                                                 │
│  /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)     │
└──────────────────────────────────────────────────────────┘

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

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.

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

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

/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

What do you need to do?
│
├─ 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
│
└─ First time setup? ─────────────────────► /start:init

validate vs review — Different purposes, different timing

analyze vs document — Discovery vs generation

refactor vs debug — Improvement vs fixing

The Agentic Startup is distributed as Claude Code marketplace plugins—native integration with zero manual configuration.

Core workflow orchestration — 9 commands, 16 skills, 2 output styles

📖 View detailed command documentation →

Specialized agent library — 11 roles, 27 activity-based specializations

📖 View all available agents →

The Start plugin includes two output styles that change how Claude communicates while working. Both maintain the same quality standards—the difference is in personality and explanation depth.

Switch anytime: /output-style start:The Startup or /output-style start:The ScaleUp

High-energy execution with structured momentum.

• Vibe: Demo day energy, Y Combinator intensity
• Voice: "Let's deliver this NOW!", "BOOM! That's what I'm talking about!"
• Mantra: "Done is better than perfect, but quality is non-negotiable"

Best for: Fast-paced sprints, high-energy execution, when you want momentum and celebration.

Calm confidence with educational depth.

• Vibe: Professional craft, engineering excellence
• Voice: "We've solved harder problems. Here's the approach."
• Mantra: "Sustainable speed at scale. We move fast, but we don't break things."

Unique feature — Educational Insights: The ScaleUp explains decisions as it works:

💡 Insight: I used exponential backoff here because this endpoint has rate limiting. The existing src/utils/retry.ts helper already implements this pattern.

Best for: Learning while building, understanding codebase patterns, onboarding to unfamiliar codebases.

Research shows 2-22% accuracy improvement with specialized task agents vs. single broad agents (Multi-Agent Collaboration, 2025). Leading frameworks organize agents by capability, not job titles. The Agentic Startup applies this research through activity-based specialization.

Development often moves too fast without proper planning:

• Features built without clear requirements
• Architecture decisions made ad-hoc during coding
• Technical debt accumulates from lack of upfront design
• Teams struggle to maintain consistency across implementations

1. Specify First — Create comprehensive specifications before writing code

• product-requirements.md — What to build and why
• solution-design.md — How to build it technically
• implementation-plan.md — Executable tasks and phases

2. Review & Refine — Validate specifications with stakeholders

• Catch issues during planning, not during implementation
• Iterate on requirements and design cheaply
• Get alignment before costly development begins

3. Implement with Confidence — Execute validated plans phase-by-phase

• Clear acceptance criteria at every step
• Parallel agent coordination for speed
• Built-in validation gates and quality checks

4. Document & Learn — Capture patterns for future reuse

• Automatically document discovered patterns
• Build organizational knowledge base
• Prevent reinventing solutions

Measure twice, cut once — Investing time in specifications saves exponentially more time during implementation.

Documentation as code — Specs, patterns, and interfaces are first-class artifacts that evolve with your codebase.

Parallel execution — Multiple specialists work simultaneously within clear boundaries, maximizing velocity without chaos.

Quality gates — Definition of Ready (DOR) and Definition of Done (DOD) ensure standards are maintained throughout.

Progressive disclosure — Skills and agents load details only when needed, optimizing token efficiency while maintaining power.

Reusable architectural patterns and design decisions:

• Start Plugin Documentation — Workflow commands and skills
• Team Plugin Documentation — Specialized agents and skills library
• Migration Guide — Upgrading from v1.x

Ready to 10x your development workflow?
Let's ship something incredible! 🚀