This guide provides specific prompt templates for each phase of spec development, with variations for different feature types and complexity levels.
Each template follows this pattern:
- Context Setting: Establish project background and constraints
- Phase-Specific Instructions: Clear guidance for the current phase
- Output Format: Specific formatting requirements
- Validation Criteria: How to evaluate the response
I want to create a spec for [FEATURE_NAME]. Here's my initial idea:
[BRIEF_FEATURE_DESCRIPTION]
Please help me create comprehensive requirements using the EARS format. Focus on:
- User stories that capture the core value proposition
- Acceptance criteria that are testable and specific
- Edge cases and error scenarios
- Integration points with existing systems
The feature should serve [TARGET_USER_TYPE] and solve [CORE_PROBLEM].
I'm planning a [SYSTEM_TYPE] that needs to handle [CORE_FUNCTIONALITY].
Key constraints:
- Performance: [PERFORMANCE_REQUIREMENTS]
- Scale: [EXPECTED_USAGE_PATTERNS]
- Integration: [EXISTING_SYSTEMS_TO_INTEGRATE]
- Compliance: [REGULATORY_OR_BUSINESS_REQUIREMENTS]
Please help me break this down into well-structured requirements using EARS format. Pay special attention to:
- System boundaries and interfaces
- Non-functional requirements
- Data flow and processing requirements
- Security and compliance considerations
I need to design an API for [API_PURPOSE]. The API should:
Core functionality:
- [PRIMARY_OPERATIONS]
- [SECONDARY_OPERATIONS]
Technical context:
- Expected consumers: [WHO_WILL_USE_IT]
- Data sources: [WHERE_DATA_COMES_FROM]
- Performance needs: [RESPONSE_TIME_REQUIREMENTS]
Please create requirements that cover:
- Endpoint specifications and data models
- Authentication and authorization
- Error handling and status codes
- Rate limiting and usage policies
Based on the requirements we've established, I need a comprehensive design for [FEATURE_NAME].
Requirements summary: [BRIEF_RECAP_OF_KEY_REQUIREMENTS]
Please create a design that addresses:
- Overall architecture and component relationships
- Data models and their relationships
- API interfaces and contracts
- Error handling strategies
- Testing approach
Consider these technical constraints:
- Technology stack: [CURRENT_TECH_STACK]
- Performance requirements: [KEY_PERFORMANCE_NEEDS]
- Integration points: [SYSTEMS_TO_INTEGRATE_WITH]
I need a detailed database design for [FEATURE_NAME] based on our requirements.
Key data entities from requirements:
- [ENTITY_1]: [BRIEF_DESCRIPTION]
- [ENTITY_2]: [BRIEF_DESCRIPTION]
- [ENTITY_3]: [BRIEF_DESCRIPTION]
Please design:
- Entity relationship diagrams
- Table schemas with appropriate constraints
- Indexing strategy for performance
- Data migration considerations
- Backup and recovery approach
Database context: [CURRENT_DATABASE_TECHNOLOGY]
Based on our requirements, I need a user experience design for [FEATURE_NAME].
User context:
- Primary users: [USER_TYPES]
- Usage patterns: [HOW_THEY_WILL_USE_IT]
- Device/platform: [WHERE_THEY_ACCESS_IT]
Please design:
- User flow diagrams
- Interface mockups or wireframes
- Interaction patterns
- Accessibility considerations
- Error state handling
Now that we have the design approved, please break it down into actionable coding tasks.
Design summary: [KEY_DESIGN_COMPONENTS]
Create an implementation plan that:
- Follows test-driven development principles
- Builds incrementally with early validation
- Sequences tasks to minimize dependencies
- Includes specific file/component creation steps
Each task should:
- Reference specific requirements it addresses
- Be completable by a coding agent
- Build on previous tasks
- Include testing considerations
I need to refactor [EXISTING_SYSTEM] to implement [NEW_FEATURE] based on our design.
Current system context:
- Existing codebase: [BRIEF_DESCRIPTION]
- Technologies used: [CURRENT_TECH_STACK]
- Areas that need changes: [COMPONENTS_TO_MODIFY]
Create tasks that:
- Minimize disruption to existing functionality
- Allow for incremental rollout
- Include comprehensive testing at each step
- Handle data migration if needed
Use concise templates focusing on:
- Core user story and acceptance criteria
- Basic architecture decisions
- Straightforward task breakdown
Include additional sections for:
- Multiple user personas
- Integration considerations
- Performance and scalability
- More detailed task sequencing
Expand templates to cover:
- System-wide impact analysis
- Detailed technical research needs
- Phased implementation approach
- Risk assessment and mitigation
Continuing from our previous discussion about [FEATURE_NAME], I'd like to [SPECIFIC_REQUEST].
Previous context:
- [KEY_POINT_1]
- [KEY_POINT_2]
- [KEY_POINT_3]
Please [SPECIFIC_ACTION] while maintaining consistency with what we've established.
I've reviewed the [REQUIREMENTS/DESIGN/TASKS] and have some feedback:
Changes needed:
1. [SPECIFIC_CHANGE_1] - [REASON]
2. [SPECIFIC_CHANGE_2] - [REASON]
3. [SPECIFIC_CHANGE_3] - [REASON]
Please update the document to incorporate these changes while maintaining the overall structure and quality.
I need clarification on [SPECIFIC_ASPECT] from the [REQUIREMENTS/DESIGN/TASKS].
Specifically:
- [QUESTION_1]
- [QUESTION_2]
- [QUESTION_3]
Please provide detailed explanations and update the document if needed to make these points clearer.
Please review the requirements document for [FEATURE_NAME] and check:
- Are all user stories complete with clear acceptance criteria?
- Do the requirements use proper EARS format?
- Are edge cases and error scenarios covered?
- Is the scope clearly defined and bounded?
- Are there any missing integration points?
Provide specific feedback on any issues found.
Please review the design document for [FEATURE_NAME] and validate:
- Does the architecture address all requirements?
- Are the component interfaces well-defined?
- Is the error handling strategy comprehensive?
- Are performance considerations addressed?
- Is the testing approach adequate?
Highlight any gaps or inconsistencies.
Please review the implementation plan for [FEATURE_NAME] and check:
- Are all tasks actionable by a coding agent?
- Do tasks build incrementally without big jumps?
- Are all requirements covered by the tasks?
- Is the sequencing logical and dependency-aware?
- Are testing tasks integrated throughout?
Suggest improvements for any issues identified.
The requirements seem too high-level. Please help me break down [SPECIFIC_REQUIREMENT] into more specific, testable acceptance criteria.
Focus on:
- Concrete user actions and system responses
- Measurable success criteria
- Specific error conditions and handling
- Clear boundaries of what's included/excluded
The design needs more technical detail for [SPECIFIC_COMPONENT]. Please expand on:
- Specific interfaces and data contracts
- Implementation approach and technology choices
- Error handling and edge case management
- Performance considerations and constraints
- Testing strategy for this component
Some tasks in the implementation plan are too abstract for direct coding. Please break down [SPECIFIC_TASK] into concrete coding steps that specify:
- Exact files or components to create/modify
- Specific functions or classes to implement
- Test cases to write
- Integration points to establish