by rsmdt
The Agentic Startup - A collection of Claude Code commands, skills, and agents.
# Add to your Claude Code skills
git clone https://github.com/rsmdt/the-startupLast scanned: 5/30/2026
{
"issues": [],
"status": "PASSED",
"scannedAt": "2026-05-30T15:08:32.643Z",
"npmAuditRan": true,
"pipAuditRan": true
}the-startup is an open-source ai agents skill for AI coding assistants such as Claude Code, Codex CLI, and ChatGPT, built by rsmdt. The Agentic Startup - A collection of Claude Code commands, skills, and agents. It has 301 GitHub stars.
Yes. the-startup passed SkillsLLM's automated security scan — a dependency vulnerability audit plus prompt-injection heuristics — with no high-severity issues. You can read the full report in the Security Report section on this page.
Clone the repository with "git clone https://github.com/rsmdt/the-startup" and add it to your Claude Code skills directory (see the Installation section above).
the-startup is primarily written in Shell. It is open-source under rsmdt on GitHub, so you can review or fork the full source.
Yes. SkillsLLM lists many other AI Agents skills you can browse and compare side by side. Open the AI Agents category from the badge at the top of this page, or use the Related Skills and comparison links further down to weigh the-startup against similar tools.
No comments yet. Be the first to share your thoughts!
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:
/specify classifies complexity and /implement auto-dispatchesRequirements: 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
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) │
│ │ ↳ 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) │
└──────────────────────────────────────────────────────────┘
/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.
/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.
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:
001) instead of a descriptionPro 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: