rsmdt/the-startup
Overview
This skill creates actionable implementation plans that break features into executable tasks following TDD principles. It produces implementation-plan.md files that map PRD acceptance criteria and SDD components to verifiable deliverables. Plans make dependencies explicit, identify parallel work, and include validation gates for specification compliance.
How this skill works
The skill reads the PLAN template and the relevant PRD/SDD sections, then generates a structured plan using Prime → Test → Implement → Validate steps for each task. Each task is a trackable unit that produces a verifiable outcome, includes specification references and activity metadata, and declares sequencing and parallelism. The final output follows the prescribed template and a PLAN status summary that highlights phases, task counts, and coverage metrics.
When to use it
- Creating a new implementation-plan.md from the template for a feature or spec
- Defining or completing phases in an existing implementation-plan.md
- Sequencing tasks and analyzing dependencies before development starts
- Planning TDD cycles and embedding validation gates into tasks
- When you need every PRD acceptance criterion and SDD component mapped to deliverables
Best practices
- Treat each task as a logical unit that yields a verifiable deliverable, not an activity
- Always include [ref: ...] links to PRD/SDD sections in Prime steps for traceability
- Embed Test-first criteria that reference PRD acceptance criteria and edge cases
- Mark concurrent work with [parallel: true] and ensure no circular dependencies
- Include a Validate step per task or a Phase Validation task to gate specification compliance
Example use cases
- Break a new payment feature into entities, adapters, and UI components with tests and validation
- Define backend API workstreams with clear sequencing, parallel groups, and test-first tasks
- Convert SDD components into implementation tasks that a developer can follow independently
- Plan an integration phase that includes E2E tests, lint/type checks, and spec validation
- Update an implementation-plan.md after a discovery phase to reflect new dependencies
FAQ
Track logical units that produce outcomes (e.g., Payment Entity), not tiny activities; each must deliver a verifiable artifact and tests.
Should timelines or personnel be included?
No. Plans focus on what to do, order, and validation. Omit time estimates and resource assignments.
21 skills
This skill creates actionable implementation plans that translate features into verifiable tasks, following TDD structure to enable autonomous developer work.
This skill helps plan, conduct, and synthesize user research across interviews, personas, journeys, and usability tests for actionable insights.
This skill helps you craft and validate solution-design documents that define architecture, interfaces, and technical decisions for clear implementation
This skill guides you through systematic code-quality reviews, improving correctness, design, security, performance, and maintainability with actionable
This skill helps you choose and document suitable system architecture patterns monolith microservices event-driven serverless for scalability.
This skill guides you through planning, conducting, and synthesizing user research to inform design decisions and validate concepts.
This skill helps you create and validate project constitutions by discovering patterns in your codebase and generating governance rules.
This skill auto-detects project tech stacks, package managers, and configuration patterns to guide framework-specific setup and tooling recommendations.
This skill helps teams prioritize features using RICE, MoSCoW, Kano, and weighted scoring to inform roadmaps and resource decisions.
This skill helps orchestrators decompose complex tasks, delegate to parallel specialists, and generate structured prompts with focus and exclude templates.
This skill helps you diagnose, baseline, and optimize performance by guiding measurement, bottleneck identification, and capacity planning.
This skill helps you design reliable observability by shaping SLIs, SLOs, traces, alerts, and dashboards for production systems.
This skill helps you perform comprehensive security assessments of code, architecture, and configurations using STRIDE patterns and secure coding practices.
This skill captures and organizes business rules, patterns, and interfaces discovered during analysis, ensuring deduplication and proper categorization.
This skill helps you diagnose bugs using a scientific, observable, conversational approach to form hypotheses, test them, and identify root causes.
This skill guides safe refactoring to preserve external behavior while reducing duplication and complexity across codebases.
This skill helps you elicit clear requirements, align stakeholders, and validate specifications using proven techniques.
This skill helps you design and implement CI/CD pipelines with deployment strategies, quality gates, and GitHub/GitLab patterns.
This skill verifies that implementations conform to documented specifications, checking interfaces, data models, and architecture to ensure compliance and
This skill helps you identify and apply consistent project patterns across codebases, ensuring naming, architecture, and testing conventions match established
This skill helps you design, document, and review REST, GraphQL, and OpenAPI contracts for consistent, evolvable APIs that developers love.
