rsmdt/the-startup

Analyze performs mechanism-level codebase analysis of business rules, architecture, auth flows, data models, integrations, and performance hotspots. Use it when you need to trace how something works before making a change.

Brainstorm explores user intent, requirements, and design before implementation. Use it before creative work to validate scope, compare approaches, and get approval on a direction.

Canonical Review orchestrates multi-agent code review with specialist perspectives and structured findings. Use it to review a PR, branch, staged changes, or files and synthesize actionable issues.

Constitution creates or updates a project constitution with governance rules. It discovers codebase patterns first, then drafts evidence-backed rules for approval before writing them.

Debug systematically diagnoses and resolves bugs through conversational investigation, reproduction, and root cause analysis. Use it when you need to trace a failure, test hypotheses, and verify a minimal fix.

Document orchestrates specialist agents to generate and maintain documentation for code, APIs, and project components. Use it when you need to check existing docs, update stale content, or add coverage with consistent links and line references.

Feature Prioritization applies RICE, MoSCoW, Kano, and related scoring frameworks to rank features and initiatives. Use it when deciding what to build, defer, or document for a roadmap.

Implement Direct coordinates low-complexity changes by delegating all coding to specialist agents, then checking results for drift. Use it for fixes, refactors, docs updates, or small features that fit in one delivery pass.

Implement Dispatcher resolves a completed spec, detects available decomposition artifacts, and routes the request to the matching execution sub-skill. Use it to hand off work to direct, incremental, or factory implementation flows.

Implement Factory orchestrates multi-agent implementation work by splitting specs into isolated code and evaluation passes. Use it for complex features with parallel workstreams, retries, and holdout-scenario checks.

Implement Incremental orchestrates single-feature implementation plans in phases with human review between steps. Use it for medium-complexity work that needs delegated coding, drift checks, and resumable progress.

Incremental Specification Planning breaks a single-feature spec into ordered implementation phases with TDD-oriented tasks. Use it for medium-complexity work that needs clear human review before implementation proceeds.

Pattern Detection identifies naming, architecture, testing, and organization patterns in an existing codebase so new code can match established conventions. Use it when generating code, reviewing changes, or checking for conflicts.

Project Discovery builds a map of a codebase by tracing structure, detecting the tech stack, and checking documentation against implementation. Use it when onboarding, finding entry points, or verifying docs.

Refactor improves code structure, naming, and readability while preserving existing behavior. Use it when you need to simplify implementation details without changing business logic or public contracts.

Requirements Elicitation turns vague requests into clear, testable specifications with stakeholders, scope boundaries, acceptance criteria, and validation checks. Use it when clarifying needs, resolving conflicts, or documenting requirements.

Review coordinates multi-agent code review across security, performance, patterns, simplification, and tests. Use it to gather synthesized feedback on code changes with strengths and actionable findings.

Specify creates a full implementation specification from a brief description. It gathers requirements, designs the solution, and routes decomposition to Direct, Incremental, or Factory based on complexity.

Specify Factory decomposes complex requirements and solution designs into unit specs, holdout scenarios, and an execution manifest. Use it for multi-feature work, multi-component changes, or parallelizable workstreams.

Specify Meta scaffolds and updates specification directories in .start/specs/. It is used to create new specs, read status, move between phases, and log decisions during the Requirements → Solution → Decomposition workflow.

Specify Requirements creates and validates product requirements documents (PRDs) for a feature or product area. Use it when writing requirements, defining user stories, setting acceptance criteria, or working in requirements.md files.

Specify Solution creates and validates solution design documents for architecture, interfaces, and technical decisions. Use it when designing system structure, tracing PRD requirements, or working in solution.md files.

Test runs the full test suite, including unit, integration, and E2E categories, to verify changes and enforce code ownership. Use it when implementation changes, bugs, or refactors need proof that everything still passes.

Validate orchestrates spec, file, drift, comparison, and constitution checks across artifacts. Use it when reviewing a spec, checking a file, detecting implementation drift, or comparing two sources.

Writing Skills helps create, audit, convert, and verify Claude Code skills against repository conventions. Use it when authoring a new skill, reviewing an existing one, or checking a skill before deployment.