the-startup

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

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

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 → task plan → Code
• One Implementation Loop — /implement runs the plan's tasks through a barriered code→eval retry loop on Claude Code's dynamic-workflow runtime
• Parallel Agent Execution — Multiple specialists work simultaneously
• Quality Gates — Built-in validation at every stage
• Zero Configuration — Marketplace plugins, one-line install

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

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

┌──────────────────────────────────────────────────────────┐
│                    SETUP (optional)                      │
│                                                          │
│  /constitution ► Create project governance rules         │
│                  (auto-enforced in BUILD workflow)       │
└──────────────────────────────────────────────────────────┘
                            │
                            ▼
┌──────────────────────────────────────────────────────────┐
│                    BUILD (primary flow)                  │
│                                                          │
│  /specify ────► Create specs (Requirements + Solution + Plan) │
│      │           ↳ Plan = ordered task sequence          │
│      │           ↳ Constitution checked on SDD           │
│      ▼                                                   │
│  /validate ───► Check quality (3 Cs framework)           │
│      │           ↳ Constitution mode available           │
│      ▼                                                   │
│  /implement ──► Run the task loop (dynamic-workflow)     │
│      │           ↳ barriered code→eval retry per task    │
│      │           ↳ Constitution 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)           │
└──────────────────────────────────────────────────────────┘

/specify Add real-time notification system with WebSocket support

This creates a specification directory with one document in three parts plus its holdout scenarios:

.start/specs/001-notification-system/
├── spec.md                  # Requirements (what and why), Solution (how), Plan (phases + outcomes), Ledger
├── review.md                # Solution review report
└── .tracker/                 # The implementation tasks /implement runs
    ├── <phase + slice tasks> # phase = one evaluated outcome; slice = one deliverable, code brief in its body
    └── <scenario tasks>      # holdout acceptance evidence, per slice

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.

The Plan part of spec.md is the high-level approach — phases and their achievable outcomes, plus a link to the tracker. The operational units are tasks in the spec's tracker (.start/specs/NNN/.tracker/, via task.js): one phase task per plan phase and, under it, one slice task per vertical deliverable, whose body correlates:

Its acceptance scenarios are separate scenario child tasks (holdout evidence — the eval agent reads them, the code agent never does). Slices declare dependencies (--depends-on) — that graph is the whole parallelization contract. There is no tier or strategy to choose: a 1-slice plan is a short loop, a 40-slice plan fans out. You always invoke /specify and /implement; the spec sub-skills (specify-requirements, specify-solution, specify-plan, specify-meta) are dispatched internally.

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.

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

/implement 001

Claude will:

1. Read the spec's slice tasks from the tracker and topologically sort them by their --depends-on edges
2. Author and run one dynamic workflow — each slice driven through a barriered code→eval loop (a code agent builds it reading the slice task, blind to its scenarios; an eval agent proves it against the slice's scenario child tasks, blind to the slice and the source; failures retry until the satisfaction threshold)
3. Run independent slices concurrently and dependent ones in order

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

/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?
│
├─ 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

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 — 10 user-invocable skills, 5 autonomous skills, 2 output styles

📖 View detailed skill documentation →

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

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

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.

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

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

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.

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

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

Both context usage and cost display color-coded warnings:

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

Example minimal format:

format = "<context>  <session>"

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

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

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

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

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

Skip what you don't need. Start with a solution design, jump straight to decomposition, or go full requirements → solution → plan. Skipped phases are logged as decisions, not gaps.

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.

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"
  }
}

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

• Requirements — What to build and why
• Solution — How to build it technically
• Plan — The phases and their slices, with holdout acceptance scenarios per slice

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 task by task

• 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 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! 🚀