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

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

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

Capability Matrix

When Skills Overlap

validate vs review — Different purposes, different timing

analyze vs document — Discovery vs generation

refactor vs debug — Improvement vs fixing

📦 Plugins

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

Start Plugin (start@the-startup)

Core workflow orchestration — 10 user-invocable skills, 5 autonomous skills, 2 output styles

📖 View detailed skill documentation →

Team Plugin (team@the-startup) — Optional

Specialized agent library — 8 roles, 20 activity-based agents. Now with experimental Agent Teams support for multi-agent collaboration.

📖 View all available agents →

🎨 Output Styles

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

The Startup 🚀

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.

The ScaleUp 📈

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.

Comparison

🔧 How Skills Work

The Agentic Startup is built on Claude Code’s skills system, which follows the Agent Skills open standard. Understanding how skills are invoked helps you get the most out of the framework.

Invocation Model

Skills have two invocation paths, controlled by frontmatter fields in each skill’s SKILL.md:

Skills from the Start plugin are invoked directly by name (e.g., /specify, /test).

User-Invocable vs Autonomous Skills

The 10 user-invocable skills are the ones you interact with directly. The 5 autonomous skills activate behind the scenes when orchestrator skills need them (e.g., specify loads specify-requirements, specify-solution, and specify-factory during the specification workflow).

Progressive Disclosure

Skills load efficiently to conserve context:

1. At startup — Only skill names and descriptions are loaded (~100 tokens each)
2. On invocation — Full SKILL.md content loads when you or Claude triggers the skill
3. On demand — Supporting files (reference.md, templates, scripts) load only when needed

This means all 15 skills can be available without consuming significant context until actually used.

📊 Statusline

The installer sets up a custom statusline that displays context usage, session cost, and other useful information directly in your Claude Code terminal.

What You See

📁 ~/C/p/project ⎇ main*  🤖 Opus 4.5 (The Startup)  🧠 ⣿⣿⡇⠀⠀ 50%  🕐 30m  💰 $1.50  ? for shortcuts

Color Thresholds

Both context usage and cost display color-coded warnings:

Configuration

The statusline reads from ~/.config/the-agentic-startup/statusline.toml:

# Format string (customize what's displayed)
format = "<path> <branch>  <model>  <context>  <session>  <help>"

# Plan for cost thresholds: "auto" | "pro" | "max5x" | "max20x" | "api"
plan = "auto"
fallback_plan = "pro"

[thresholds.context]
warn = 70    # percentage
danger = 90

[thresholds.cost]
# Uncomment to override plan defaults:
# warn = 2.00
# danger = 5.00

Plan-Based Cost Defaults

Format Placeholders

Example minimal format:

format = "<context>  <session>"

💡 Why The Agentic Startup?

Real workflow features that solve real problems — not just another AI wrapper.

Resume Across Sessions

Hit a context limit? Start a new conversation and pick up exactly where you left off. Specs persist on disk — Claude reads them and continues.

/specify 001    # ← resumes spec creation from where you left off
/implement 001  # ← resumes implementation, tracking progress in spec files

Code Ownership Mandate

No more “pre-existing failure” excuses. When /test finds a failing test, it fixes it — period. You touched the codebase, you own it.

Drift Detection

Implementation drifting from the spec? Caught automatically during /implement. Scope creep, missing items, contradictions — flagged with options to update the spec or the code.

Adaptive Code Review

/review auto-detects what matters. Async code triggers concurrency review. Dependency changes trigger supply-chain checks. UI changes trigger accessibility audits. 5 base perspectives + conditional specialists.

Implement Any Plan

Not just for specs created with /specify. /implement works with any markdown implementation plan — bring your own architecture docs, migration guides, or design documents.

/implement path/to/plan.md

Non-Linear Specs

Skip what you don’t need. Start with a solution design, jump straight to decomposition, or go full PRD → SDD → tier-appropriate decomposition. Skipped phases are logged as decisions, not gaps.

Adversarial Debugging

Tough bugs get multiple investigators that actively try to disprove each other’s hypotheses. The surviving theory is most likely the root cause — competing hypotheses, not confirmation bias.

Agent Teams (Experimental) — New in v3

Enable multi-agent collaboration where specialized agents coordinate autonomously on complex tasks. The installer configures this automatically, or enable manually:

// ~/.claude/settings.json
{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

🎯 Philosophy

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.

The Problem We Solve

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

Our Approach

1. Specify First — Create comprehensive specifications before writing code

• requirements.md — What to build and why
• solution.md — How to build it technically
• plan/ — Executable tasks and phases (README.md manifest + phase-N.md files)

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

Core Principles

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

📚 Documentation

Patterns

Reusable architectural patterns and design decisions:

Additional Resources

• Start Plugin Documentation — Workflow 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! 🚀