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.
Start claude and run the following:
# 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.
| Tier | When to use | Decomposition output | Implementation flow |
|---|
| Direct | Fixes, refactors, doc changes, single-AC features | none β requirements.md + solution.md only | implement-direct: lightweight 1β3 unit orchestration, drift check, no intermediate artifact |
| Incremental | Single feature with one or two components | plan/README.md + plan/phase-N.md (linear phase plan with TDD tasks) | implement-incremental: phase-by-phase loop with frontmatter status, human-in-the-loop review |
| Factory | Multi-feature, multi-component, parallel-eligible work | manifest.md + units/{id}.md + scenarios/{unit-id}/{name}.md | implement-factory: parallel unit dispatch with information barriers, holdout scenarios, and retry to a satisfaction threshold |
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:
- Autodetect the decomposition tier by inspecting the spec directory (
plan/ β Incremental, manifest.md β Factory, neither β Direct)
- Dispatch to the matching execution sub-skill (
implement-direct, implement-incremental, or implement-factory)
- 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)
- 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
| Skill | Purpose | When to Use |
|---|
/constitution | Create governance rules | Establish project-wide guardrails |
/specify | Create specifications, classify complexity, decompose at the chosen tier | New features, fixes, refactors β any work that benefits from a written spec |
/implement | Auto-dispatch by tier (Direct / Incremental / Factory) and execute | After spec is validated |
/validate | Check quality | Before implementation, after specs |
/test | Run tests, enforce ownership | After implementation, fixing bugs |
/review | Multi-agent code review | Before merging PRs |
/document | Generate documentation | After implementation |
/analyze | Extract knowledge | Understanding existing code |
/refactor | Improve code quality | Cleanup without behavior change |
/debug | Fix bugs | When something is broken |
Capability Matrix
| Capability | constitution | specify | implement | validate | test | review | document | analyze | refactor | debug |
|---|
| Creates specifications | - | β
| - | - | - | - | - | - | - | - |
| Executes implementation plans | - | - | β
| - | - | - | - | - | - | - |
| Runs tests | - | - | β
| β
| β
| - | - | - | β
| β
|
| Creates git branches | - | β
| β
| - | - | - | - | - | β
| - |
| Creates PRs | - | β
| β
| - | - | - | - | - | - | - |
| Multi-agent parallel | - | β
| β
|
When Skills Overlap
validate vs review β Different purposes, different timing
| Aspect | /validate | /review |
|---|
| When | During development | Before merging |
| Focus | Spec compliance, quality gates | Code quality, security, performance |
| Output | Advisory recommendations | PR comments, findings report |
analyze vs document β Discovery vs generation
| Aspect | /analyze | /document |
|---|
| Purpose | Discover what exists | Generate documentation |
| Output | Knowledge documentation | API docs, READMEs, JSDoc |
refactor vs debug β Improvement vs fixing
| Aspect | /refactor | /debug |
|---|
| Behavior | Must preserve exactly | Expected to change (fix) |
| Tests | Must all pass throughout | May need new/updated tests |
π¦ 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
| Category | Capabilities |
|---|
| Setup | Environment configuration (init), project governance rules (constitution) |
| Build | specify β validate β implement pipeline with parallel agent coordination |
| Quality | Multi-agent code review, security scanning, constitution enforcement, drift detection |
| Maintain | Documentation generation, codebase analysis, safe refactoring, debugging |
| Git | Optional branch/commit/PR workflows integrated into skills |
π 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.
| Role | Focus Areas |
|---|
| Chief | Complexity assessment, activity routing, parallel execution |
| Analyst | Requirements, prioritization, project coordination |
| Architect | System design, technology research, quality review, documentation |
| Software Engineer | APIs, components, domain modeling, performance |
| QA Engineer | Test strategy, exploratory testing, load testing |
| Designer | User research, interaction design, design systems, accessibility |
| Platform Engineer | IaC, containers, CI/CD, monitoring, data pipelines |
| Meta Agent | Agent design and generation |
π 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
| Dimension | The Startup | The ScaleUp |
|---|
| Energy | High-octane, celebratory | Calm, measured |
| Explanations | Minimalβships fast | Educational insights included |
| On failure | "That didn't work. Moving on." | "Here's what failed and why..." |
| Closing thought | "What did we deliver?" | "Can the team maintain this?" |
π§ 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:
| Path | How It Works | Controlled By |
|---|
| User slash command | You type /skill-name [args] | user-invocable (default: true) |
| Model auto-invocation | Claude detects context and loads the skill via the Skill tool | disable-model-invocation (default: false) |
Skills from the Start plugin are invoked directly by name (e.g., /specify, /test).
User-Invocable vs Autonomous Skills
| Type | Visible in / menu? | Claude auto-invokes? | Example |
|---|
| User-invocable | Yes | Yes | /specify β you trigger the spec workflow |
| Autonomous | No | Yes | specify-requirements β loaded by specify when creating PRDs |
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:
- At startup β Only skill names and descriptions are loaded (~100 tokens each)
- On invocation β Full
SKILL.md content loads when you or Claude triggers the skill
- 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
| Component | Description |
|---|
π ~/C/p/project | Current directory (abbreviated) |
β main* | Git branch (* indicates uncommitted changes) |
π€ Opus 4.5 (The Startup) | Model and output style |
π§ β£Ώβ£Ώβ‘β β 50% | Context window usage (color-coded) |
π 30m | Session duration |
π° $1.50 | Session cost (color-coded by plan) |
Color Thresholds
Both context usage and cost display color-coded warnings:
| Color | Context | Cost (Pro plan) |
|---|
| π’ Green | < 70% | < $1.50 |
| π‘ Amber | 70-89% | $1.50 - $4.99 |
| π΄ Red | β₯ 90% | β₯ $5.00 |
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
| Plan | Monthly | Warn | Danger |
|---|
pro | $20 | $1.50 | $5.00 |
max5x | $100 | $5.00 | $15.00 |
max20x | $200 | $10.00 | $30.00 |
api | Pay-as-you-go | $2.00 | $10.00 |
Format Placeholders
| Placeholder | Description | Example |
|---|
<path> | Abbreviated directory | ~/C/p/project |
<branch> | Git branch with dirty indicator | β main* |
<model> | Model and output style | π€ Opus 4.5 (The Startup) |
<context> | Context usage bar and percentage | π§ β£Ώβ£Ώβ‘β β 50% |
<session> | Duration and cost | π 30m π° $1.50 |
<lines> | Lines added/removed | +156/-23 |
<spec> | Active spec ID (when in .start/specs/) | π 005 |
<help> | Help text | ? for shortcuts |
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
