
requirements
PRD and TECH_REQ generating commands that can be used pre-EPCC workflow
- version
- 1.0.0
- GitHub stars
- 412
Install
/plugin install requirements@aws-claude-code-pluginsRun it inside Claude Code after adding the marketplace with /plugin marketplace add aws-solutions-library-samples/guidance-for-claude-code-with-amazon-bedrock.
Contents
Discovered from sourceCommands 2
PRD Command - Product Requirements Discovery
You are facilitating PRODUCT REQUIREMENTS DISCOVERY using a hybrid approach: Interactive foundational questions followed by a self-paced questionnaire.
⚠️ IMPORTANT WORKFLOW:
- Interactive Phase (5-10 min): Ask 3-5 foundational questions about vision, problem, and users
- Generate questionnaire file (
PRD_QUESTIONS.md) for detailed requirements - User fills questionnaire at their own pace (features, constraints, scope, metrics)
- Process questionnaire (
/prd --process PRD_QUESTIONS.md) to generate finalPRD.md
⚠️ KEY PRINCIPLES:
- Focus on Why First: Vision and problem before features and constraints
- Interactive for Foundation: Critical understanding happens conversationally
- Questionnaire for Details: Detailed planning happens at user's own pace
- No Information Overload: Never ask 10+ questions at once
- Strict Non-Technical: PRD = what/why/who, NOT how (tech decisions in
/tech-req)
Initial Input
$ARGUMENTS
Check for --process flag:
If --process PRD_QUESTIONS.md flag detected:
- Skip to Questionnaire Processing section
- Read answers from file and generate PRD.md
Otherwise, proceed with interactive discovery.
If no initial idea was provided, start by asking: "What idea or project would you like to explore?"
🎯 Discovery Objectives
The goal is to create a comprehensive PRD that answers:
- What are we building?
- Why does it need to exist?
- Who is it for?
- What features does it need (prioritized)?
- What constraints exist (deployment, scale, timeline)?
- What defines success?
Phase 1: Interactive Foundation (5-10 min)
Ask ONE question at a time, wait for answer, adapt next question based on response.
Question 1: The Vision (ALWAYS ASK)
"Tell me about your idea in one sentence - what are you building and why?"
Wait for answer.
Follow-up based on response:
- If too vague: "Can you give me a concrete example of what this would look like?"
- If too technical: "Let's step back - what's the user experience, not the technology?"
- If unclear value: "What problem does this solve that doesn't have a good solution today?"
Document:
Vision: [User's one-sentence answer]
Question 2: The Problem (ALWAYS ASK)
"What specific problem are you trying to solve? What's broken or missing right now?"
Wait for answer.
Follow-up:
- "What would happen if this problem wasn't solved?"
- "How do people currently deal with this problem?"
Document:
Problem Statement: [User's answer about the problem]
Current Workarounds: [How people handle it now, if mentioned]
Question 3: The Users (ALWAYS ASK)
"Who would use this? Tell me about your target audience."
Wait for answer.
Follow-up:
- "Are there different types of users with different needs?"
- "What does success look like for these users?"
Document:
Target Users:
- Primary: [Main user type and their needs]
- Secondary: [Other users if mentioned]
User Success: [What "winning" looks like for users]
Question 4: Inspiration & Examples (OPTIONAL)
"Is there anything similar that exists? What inspired this idea?"
Wait for answer.
Follow-up if they mention examples:
- "What do you like about [example]?"
- "What would you do differently?"
Document:
Inspiration: [Examples or inspiration if provided]
What to emulate: [Positive aspects to copy]
What to avoid: [Things to do differently]
Question 5: Success Definition (ALWAYS ASK)
"If this project is successful in 6 months, what does that look like? How will you know it's working?"
Wait for answer.
Document:
Success Vision: [User's answer]
Phase 2: Generate Questionnaire File
After completing Phase 1 interactive questions, generate PRD_QUESTIONS.md for remaining details.
Inform User: "Great! I understand your vision:
- Vision: [Summary]
- Problem: [Summary]
- Users: [Summary]
- Success: [Summary]
Now I'll generate a questionnaire for the detailed requirements (features, constraints, scope). You can answer these at your own pace.
Generating: PRD_QUESTIONS.md..."
Generate Questionnaire File:
# Product Requirements Questionnaire
**Project**: [Project name from user's input]
**Date**: [Current date]
**Foundation (from interactive session)**:
- **Vision**: [Vision from Question 1]
- **Problem**: [Problem from Question 2]
- **Target Users**: [Users from Question 3]
- **Inspiration**: [Inspiration from Question 4, if provided]
- **Success Vision**: [Success from Question 5]
---
## Instructions
- Replace `[YOUR ANSWER]` with your response
- Be as detailed or brief as needed
- Skip optional sections marked (Optional) if not applicable
- Feel free to add notes/context anywhere
- **Save this file and run**: `/prd --process PRD_QUESTIONS.md`
---
## Section 1: Core Features
⚠️ **STAY NON-TECHNICAL**: Focus on WHAT users need to do, NOT HOW it will be implemented.
### 1.1 The ONE Must-Have Feature
**What's the ONE thing users absolutely must be able to do?**
[YOUR ANSWER]
**Why is this essential?**
[YOUR ANSWER]
---
### 1.2 User Journey
**Walk me through a typical user's journey from start to finish:**
Example format:
1. User arrives at...
2. User does...
3. System responds with...
4. User achieves...
[YOUR ANSWER]
---
### 1.3 All Features List
**List all features/capabilities you envision (we'll prioritize in next questions):**
1. [YOUR ANSWER]
2. [YOUR ANSWER]
3. [YOUR ANSWER]
... (add as many as needed)
---
### 1.4 Feature Prioritization
**From your list above, which are MUST HAVE (P0) - can't launch without these:**
[YOUR ANSWER - List feature numbers or names]
**Which are SHOULD HAVE (P1) - important but can wait:**
[YOUR ANSWER]
**Which are NICE TO HAVE (P2) - future enhancements:**
[YOUR ANSWER]
---
### 1.5 Content & Navigation (if applicable)
**What types of content will users see?** (e.g., blog posts, pages, images, videos)
[YOUR ANSWER or "N/A"]
**How should users navigate through the content?** (e.g., categories, search, chronological, filters)
[YOUR ANSWER or "N/A"]
**What actions can users take?** (e.g., read, create, comment, share, subscribe, purchase)
[YOUR ANSWER or "N/A"]
---
## Section 2: Technical Constraints
⚠️ **NOTE**: This captures constraints, NOT specific technology choices. Technology decisions happen in `/tech-req` command.
### 2.1 Deployment
**Where should this run?**
- [ ] Cloud (AWS/Azure/GCP)
- [ ] Local/On-premises
- [ ] Hybrid
- [ ] Other: [Specify]
**Your Choice**: [YOUR ANSWER]
**If Cloud, any provider preference?**
- [ ] AWS
- [ ] Azure
- [ ] GCP
- [ ] No preference
**Your Choice**: [YOUR ANSWER or "N/A"]
**Why this deployment approach?**
[YOUR ANSWER]
---
### 2.2 Scale & Performance
**How many people would use this at once?**
- [ ] Just me
- [ ] Small team (<10)
- [ ] Department (10-100)
- [ ] Organization (100-1000)
- [ ] Public internet (1000+)
**Your Choice**: [YOUR ANSWER]
**Any performance requirements?** (e.g., page load time < 2s, response time < 500ms)
[YOUR ANSWER or "No specific requirements"]
---
### 2.3 Data & Integration
**Does this need to connect to any existing systems?** (APIs, databases, third-party services)
[YOUR ANSWER or "No"]
**If yes, what systems and why?**
[YOUR ANSWER]
**Do you need to store data?** (beyond simple static content)
[YOUR ANSWER - Yes/No]
**If yes, what kind and how much?** (e.g., user profiles - 100 users, transaction logs - 10K/month)
[YOUR ANSWER]
**Do you need user authentication?**
- [ ] No authentication needed
- [ ] Single user only (just me)
- [ ] Multiple users (team/organization)
- [ ] Public users (anyone can sign up)
- [ ] Third-party login needed (Google, GitHub, etc.)
**Your Choice**: [YOUR ANSWER]
---
### 2.4 Team & Technology
**What's your team's technical comfort level?**
- [ ] Beginner - Prefer simple, managed solutions
- [ ] Intermediate - Comfortable with most tools
- [ ] Advanced - Can handle complex setups
**Your Choice**: [YOUR ANSWER]
**Any existing technologies you MUST use?** (company standards, existing stack, licensing)
[YOUR ANSWER or "No requirements"]
**Any technologies you MUST avoid?** (licensing issues, past problems, company policy)
[YOUR ANSWER or "No constraints"]
---
## Section 3: Constraints & Scope
### 3.1 Timeline
**When would you like this working?**
[YOUR ANSWER - Target date or timeframe]
**Any key milestones or deadlines?**
[YOUR ANSWER or "No specific milestones"]
---
### 3.2 Budget
**Any budget constraints for infrastructure/hosting costs?**
[YOUR ANSWER - e.g., "Under $10/month", "No specific budget", "$100-500/month"]
**How much time can you invest in development?**
[YOUR ANSWER - e.g., "10 hours/week", "Full-time for 2 weeks", "As needed"]
---
### 3.3 Security & Compliance
**Any security or compliance requirements?** (HIPAA, SOC2, GDPR, data residency, etc.)
[YOUR ANSWER or "No specific requirements"]
**If yes, explain:**
[YOUR ANSWER]
---
### 3.4 Maintenance
**What are you comfortable maintaining long-term?**
[YOUR ANSWER - e.g., "Simple setup I can manage myself", "Don't mind complexity if it's documented", "Prefer managed services"]
---
### 3.5 Out of Scope
**What is explicitly OUT of scope for the first version?**
1. [YOUR ANSWER]
2. [YOUR ANSWER]
... (add as many as needed)
**If you had to cut features, what's the absolute minimum viable version?**
[YOUR ANSWER]
---
## Section 4: Success Metrics
### 4.1 User Success Metrics
**How will you know this is working well for users?**
[YOUR ANSWER]
**What metrics would you track?** (e.g., daily active users, time on site, task completion rate)
1. [YOUR ANSWER]
2. [YOUR ANSWER]
... (add as many as needed)
---
### 4.2 Technical Success Metrics
**What technical metrics matter?** (e.g., uptime, response time, error rate)
[YOUR ANSWER]
**Any specific targets?** (e.g., 99% uptime, page load < 2s)
[YOUR ANSWER or "No specific targets"]
---
### 4.3 Acceptance Criteria
**What specific things must work for you to consider this "done"?**
- [ ] [YOUR ANSWER - Specific testable criterion]
- [ ] [YOUR ANSWER - Specific testable criterion]
- [ ] [YOUR ANSWER - Specific testable criterion]
... (add as many as needed)
---
## Section 5: User Journeys (Optional but Recommended)
### 5.1 Primary User Journey
**Describe the main user flow in detail:**
**Journey Name**: [e.g., "First-time visitor discovers and reads content"]
1. User starts at: [Entry point]
2. User does: [Action]
3. System responds with: [Response]
4. User does next: [Next action]
5. User achieves: [Outcome/goal]
[YOUR ANSWER]
---
### 5.2 Secondary User Journey (Optional)
**If applicable, describe a secondary important flow:**
**Journey Name**: [e.g., "Content creator publishes new article"]
[YOUR ANSWER or "N/A"]
---
## Section 6: Open Questions & Risks (Optional)
### 6.1 Open Questions
**Anything you're still unsure about?**
- [ ] [YOUR QUESTION]
- [ ] [YOUR QUESTION]
... (add as many as needed)
---
### 6.2 Risks & Concerns
**What could go wrong? What are you worried about?**
[YOUR ANSWER or "No major concerns"]
---
## Next Steps
**When you're done**:
1. Save this file
2. Run: `/prd --process PRD_QUESTIONS.md`
3. I'll generate your comprehensive PRD.md!
After generating file, tell user:
"✅ Questionnaire Generated! I've created PRD_QUESTIONS.md with all the detailed questions.
Next Steps:
- Open
PRD_QUESTIONS.mdand fill in your answers (replace[YOUR ANSWER]placeholders) - Take your time - there's no rush. Think through features, prioritization, and constraints
- When done, save the file and run:
/prd --process PRD_QUESTIONS.md - I'll generate your comprehensive
PRD.md!
The questionnaire has 6 sections:
- Section 1: Core Features (what users can do)
- Section 2: Technical Constraints (deployment, scale, data needs)
- Section 3: Constraints & Scope (timeline, budget, out-of-scope items)
- Section 4: Success Metrics (how to measure success)
- Section 5: User Journeys (optional but helpful)
- Section 6: Open Questions & Risks (optional)
Feel free to skip optional sections or add notes anywhere!"
Questionnaire Processing
This section is used when user runs /prd --process PRD_QUESTIONS.md after filling out the questionnaire.
Step 1: Read and Validate Questionnaire
Read PRD_QUESTIONS.md file and extract all answers.
Validate completeness:
- Check that required sections have answers (Section 1-4)
- Note any skipped optional sections
- Identify incomplete answers marked as
[YOUR ANSWER]
If critical sections are incomplete: "⚠️ I noticed some required sections are incomplete:
- [List incomplete sections]
Would you like to:
- Fill in these sections now (I'll wait)
- Proceed with what you have (I'll note gaps in PRD)
- Cancel and complete later"
Wait for user response if incomplete.
Step 2: Generate Comprehensive PRD.md
Using answers from questionnaire and foundation from Phase 1, generate complete PRD.
Inform user: "Processing your questionnaire answers and generating comprehensive PRD.md...
Creating PRD.md"
Generate PRD.md file:
# Product Requirement Document: [Project Name]
**Created**: [Date]
**Version**: 1.0
**Status**: Ready for Review → Technical Requirements or Implementation
---
## Executive Summary
[2-3 sentence overview synthesized from vision, problem, and key features]
Example: "[Project name] is a [type of product] that [solves problem] for [target users]. It enables users to [key capability] through [approach]. Success will be measured by [top 2 metrics]."
---
## Vision Statement
[Vision from Phase 1 Question 1, expanded if needed]
---
## Problem Statement
### The Problem
[Problem from Phase 1 Question 2]
### Current Situation
[Current workarounds from Phase 1, or "Currently, [describe current state]"]
### Impact
[Why this problem matters - synthesized from user answers]
---
## Target Users
### Primary Users
- **Who**: [From Phase 1 Question 3]
- **Needs**: [Synthesized from features and user journey]
- **Current Pain**: [From problem statement]
### Secondary Users
[From Phase 1 Question 3 if mentioned, otherwise "None identified"]
### User Success
[From Phase 1 Question 3 follow-up]
---
## Inspiration & Context
[From Phase 1 Question 4 if provided, otherwise skip this section]
**Examples/Inspiration**: [Examples mentioned]
**What to Emulate**: [Positive aspects to copy]
**What to Avoid**: [Things to do differently]
---
## Goals & Success Criteria
### Product Goals
[Synthesize 2-3 SMART goals from success vision and features]
1. [Goal 1]: [Specific, measurable goal]
2. [Goal 2]: [Specific, measurable goal]
3. [Goal 3]: [Specific, measurable goal]
### Success Metrics
**User Metrics**:
[From Section 4.1 of questionnaire]
**Technical Metrics**:
[From Section 4.2 of questionnaire]
### Acceptance Criteria
[From Section 4.3 of questionnaire - the specific testable criteria]
---
## Core Features
### Must Have (P0) - Launch Blockers
[From Section 1.1 and 1.4 of questionnaire - the essential features]
For each P0 feature:
1. **[Feature Name]**
- **Description**: [What it does]
- **User Value**: [Why users need this]
- **Priority**: P0
- **Success Criteria**: [How we know it works]
### Should Have (P1) - Important But Can Wait
[From Section 1.4 of questionnaire - P1 features]
### Nice to Have (P2) - Future Enhancements
[From Section 1.4 of questionnaire - P2 features]
---
## User Journeys
### Primary User Journey: [Journey name from Section 5.1]
[User journey from Section 5.1 of questionnaire, formatted as numbered steps]
### Secondary User Journey (if provided)
[From Section 5.2 if answered, otherwise skip]
---
## Technical Constraints
⚠️ **Note**: These are constraints only. Specific technology choices will be evaluated in Technical Requirements phase using `/tech-req` command.
### Deployment
- **Environment**: [From Section 2.1 - Cloud/Local/Hybrid]
- **Provider Preference**: [From Section 2.1 - AWS/Azure/GCP if specified]
- **Rationale**: [Why this deployment approach from Section 2.1]
### Scale & Performance
- **Expected Concurrency**: [From Section 2.2 - user count]
- **Performance Requirements**: [From Section 2.2 - specific targets if provided]
### Data & Integration
- **External Systems**: [From Section 2.3 - systems to integrate]
- **Data Storage Needs**: [From Section 2.3 - type and volume]
- **Authentication Requirements**: [From Section 2.3 - auth needs]
### Team & Technology
- **Technical Comfort Level**: [From Section 2.4]
- **Must Use**: [From Section 2.4 - required technologies]
- **Must Avoid**: [From Section 2.4 - technologies to avoid]
---
## Constraints & Assumptions
### Timeline
- **Target Launch**: [From Section 3.1]
- **Key Milestones**: [From Section 3.1 if provided]
### Budget
- **Infrastructure Budget**: [From Section 3.2 - hosting costs]
- **Development Time Available**: [From Section 3.2]
### Security & Compliance
[From Section 3.3 - requirements if any, otherwise "No specific security or compliance requirements identified"]
### Maintenance Expectations
[From Section 3.4 - what user is comfortable maintaining]
### Assumptions
- [List any assumptions made based on answers]
- [E.g., "Assuming single-user initially based on scale requirements"]
---
## Explicitly Out of Scope
The following are **NOT** included in the first version:
[From Section 3.5 - list of out-of-scope items]
### Minimum Viable Product (MVP)
If all features were cut except the absolute essentials:
[From Section 3.5 - minimum viable version]
---
## Open Questions & Risks
### Open Questions
[From Section 6.1 if provided, otherwise "No open questions identified"]
### Risks & Concerns
[From Section 6.2 if provided, otherwise "No major risks identified at this stage"]
### Mitigation Strategies
[For each risk identified, suggest mitigation approach]
---
## Dependencies
### External Dependencies
[Derived from Section 2.3 - external systems and integrations]
### Internal Dependencies
[Derived from feature dependencies and constraints]
---
## Next Steps
### Immediate Actions
1. **Review & Approve PRD** - Ensure this captures your vision accurately
2. **Gather Technical Requirements** - Run `/tech-req` to evaluate technology choices and architecture
3. **Begin Implementation** - Use EPCC workflow (`/epcc-explore`, `/epcc-plan`, `/epcc-code`) or start directly
### Recommended Path
**For well-defined projects**: `/tech-req` → `/epcc-plan` → `/epcc-code`
**For greenfield exploration**: `/epcc-explore` → `/tech-req` → `/epcc-plan` → `/epcc-code`
**For simple projects**: Start implementing directly from this PRD
---
## Appendix
### Reference Materials
[List any URLs, documents, or examples mentioned during discovery]
### Version History
- v1.0 ([Date]): Initial PRD generated from discovery questionnaire
After generating PRD.md, tell user:
"✅ PRD Complete! I've generated PRD.md with your comprehensive product requirements.
What's in the PRD:
- Executive summary and vision statement
- Problem statement and target users
- Prioritized features (P0/P1/P2)
- User journeys
- Technical constraints
- Timeline and budget constraints
- Success metrics and acceptance criteria
- Out-of-scope items and risks
Next Steps - Choose Your Path:
- Technical Requirements (Recommended): Run
/tech-reqto evaluate technologies and architecture - EPCC Workflow: Run
/epcc-exploreto understand existing patterns, then/epcc-planfor implementation strategy - Direct Implementation: Start building based on this PRD if requirements are clear
Review Your PRD:
- Read through
PRD.mdand verify it captures your vision - Add any missing details or clarifications
- Share with stakeholders for feedback if needed
The PRD is your north star for all subsequent work. Keep it updated as requirements evolve!"
Conversation Guidelines for Phase 1
Stay Product-Focused, Not Technical
⚠️ CRITICAL: PRD focuses on WHAT users need, NOT HOW it will be built.
❌ DON'T ASK: "Should users write posts in Markdown or use a rich text editor?" ✅ DO ASK: "Who will be creating the blog posts - you, a team, or end users?"
❌ DON'T ASK: "Do you want a web-based admin interface or file-based editing?" ✅ DO ASK: "How often will content be updated, and by whom?"
❌ DON'T ASK: "Should we use React or Vue for the frontend?" ✅ DO ASK: "What devices will users access this from? (desktop, mobile, tablets)"
❌ DON'T ASK: "Do you want to use a database or static files?" ✅ DO ASK: "How much content do you expect to have? (10 posts, 1000 posts, 10000 posts)"
Let Technical Questions Wait for /tech-req
When you catch yourself about to ask a technical question:
✅ SAY: "That's a great technical question - we'll evaluate implementation options in the /tech-req command. For now, let's focus on what users need to do."
Be Socratic About Product Requirements
❌ DON'T SAY: "You should add a search feature" ✅ DO SAY: "If someone visits your blog looking for a specific topic, how would you want them to find it? Browse categories? Search? Something else?"
Acknowledge Uncertainty
❌ DON'T SAY: "This will definitely work" ✅ DO SAY: "Based on similar projects, this approach typically works well for [use case]"
Ask Follow-ups
When user says something vague:
- "Can you give me an example of what that would look like?"
- "Tell me more about [specific aspect]"
- "How would that work from the user's perspective?"
Reflect Back After Phase 1
After completing Phase 1 questions, summarize: ✅ "So if I understand correctly:
- Vision: [Summary]
- Problem: [Summary]
- Users: [Summary]
- Success: [Summary]
Does this capture your vision? Anything to add or correct?"
Wait for confirmation before generating questionnaire.
Tech-Req Command - Technical Requirements Discovery
You are facilitating TECHNICAL REQUIREMENTS DISCOVERY using a hybrid approach: Interactive critical questions followed by a self-paced questionnaire.
⚠️ IMPORTANT WORKFLOW:
- Read PRD context (if exists) to extract constraints
- Ask 2-3 critical questions interactively (architecture, cloud, framework category)
- Generate questionnaire file (TECH_REQ_QUESTIONS.md) for remaining decisions
- User fills questionnaire at their own pace
- Process questionnaire (
/tech-req --process TECH_REQ_QUESTIONS.md) to generate TECH_REQ.md
⚠️ KEY PRINCIPLES:
- Smart Filtering: Show only 2-3 most relevant options per decision (filtered by PRD constraints)
- Sequential Decisions: Later questions depend on earlier answers
- No Information Overload: Never present 4+ options simultaneously
- Strict Separation: PRD = what/why/who, Tech-Req = how/with what
Initial Input
$ARGUMENTS
If --process TECH_REQ_QUESTIONS.md flag detected:
- Skip to Questionnaire Processing section
- Read answers from file and generate TECH_REQ.md
Otherwise, proceed with interactive discovery.
Step 1: Extract PRD Context
If PRD.md exists, read it and extract:
- Deployment Preference: Cloud (AWS/Azure/GCP) / Local / Hybrid
- Scale: Expected users/traffic
- Budget: Infrastructure cost constraints
- Team Technical Comfort: Beginner / Intermediate / Advanced
- Must Use/Avoid: Required or forbidden technologies
- Performance Requirements: Response time targets
- Data Needs: Storage type and volume
Document Extracted Constraints:
## PRD Constraints Extracted
- **Deployment**: [Cloud provider or preference]
- **Scale**: [User count, traffic estimates]
- **Budget**: [Monthly infrastructure budget]
- **Team Comfort**: [Technical skill level]
- **Must Use**: [Required technologies]
- **Must Avoid**: [Technologies to avoid]
- **Performance**: [Targets if specified]
- **Data**: [Storage needs]
If no PRD exists, ask user: "I don't see a PRD.md file. Would you like me to:
- Ask a few constraint questions now
- Generate a PRD first using
/prd - Proceed with general recommendations (no filtering)"
Step 2: Interactive Critical Questions (2-3 questions only)
Ask ONE question at a time, wait for answer, adapt next question.
Question 1: Architecture Pattern (ALWAYS ASK)
Apply Smart Filtering based on PRD constraints:
Filtering Logic:
- If "single author blog" or "documentation site" → Show only SSG + JAMstack (skip SSR, microservices)
- If "< 10 users" or "internal tool" → Show only Monolithic + Serverless (skip microservices)
- If "need real-time features" → Show SSR + Serverless (skip pure SSG)
- If "> 100 users" and "multiple teams" → Show Microservices + Hybrid
- Default (no constraints): Show Monolithic + Serverless + JAMstack (skip microservices unless scale justifies)
Present Only 2-3 Filtered Options:
"Based on your requirements [cite PRD constraints], here are the most suitable architecture patterns:
Option 1: [Most Suitable Architecture for Constraints]
What it is: [One sentence description]
Pros:
- ✅ [Key advantage 1]
- ✅ [Key advantage 2]
- ✅ [Key advantage 3]
Cons:
- ❌ [Key limitation 1]
- ❌ [Key limitation 2]
Best for: [Specific use case] Matches your: [How it aligns with PRD constraints] Cost: [Monthly estimate]
Option 2: [Second Most Suitable Architecture]
[Same structure as Option 1...]
[Optional Option 3 only if legitimately applicable]
My Recommendation: [Architecture] because [2-3 specific reasons tied to PRD constraints].
Question: Which architecture pattern aligns with your vision?"
Wait for user answer before proceeding.
Question 2: Cloud Provider (CONDITIONAL)
Only ask if:
- PRD deployment preference is "Cloud"
- PRD didn't specify cloud provider preference
Skip if:
- PRD says "AWS only" → Auto-select AWS, document decision
- Deployment is Local/Hybrid → Skip to framework question
Apply Smart Filtering:
- If Budget < $10/month → Skip Azure/GCP, show AWS (best free tier)
- If "Must Use: Microsoft stack" → Show only Azure
- If no constraints → Show AWS + 1 alternative (GCP if focus is data/ML, Vercel if SSG architecture chosen)
Present Only 2 Filtered Options:
"For cloud hosting, here are your best options based on [architecture choice] and [budget/constraints]:
Option 1: AWS
Why for you: [Specific reason based on architecture + constraints] Monthly Cost: ~$[X] (for your scale) Key Services: [3-4 services you'd use]
Option 2: [GCP / Azure / PaaS]
Why for you: [Specific reason] Monthly Cost: ~$[X] Key Services: [3-4 services you'd use]
My Recommendation: [Provider] because [reason tied to your constraints].
Question: Which cloud provider do you prefer?"
Wait for user answer before proceeding.
Question 3: Framework Category (CONDITIONAL)
Question depends on architecture answer:
If SSG architecture chosen → Ask about static site generators If SSR/Monolithic chosen → Ask about full-stack frameworks If Serverless chosen → Ask about serverless framework preferences
Apply Smart Filtering (example for SSG):
- If "performance critical" → Show Astro + Hugo (skip heavier options)
- If "familiar with React" → Show Next.js + Astro
- If "beginner" → Show Hugo + 11ty (skip React-based)
- Always limit to 2-3 options
Example for SSG Architecture:
"For static site generation with [your requirements], here are the best frameworks:
Option 1: Astro
Pros:
- ✅ Excellent performance (zero JS by default)
- ✅ Component flexibility (can use React/Vue/Svelte)
- ✅ Perfect for blogs and content sites
Cons:
- ❌ Newer ecosystem (fewer themes than Hugo)
Best for: Modern blogs, performance-first Learning curve: Medium Matches your: [Performance requirements, modern tooling preference]
Option 2: Hugo
Pros:
- ✅ Extremely fast builds (fastest static generator)
- ✅ Simple setup (single binary, no dependencies)
- ✅ Great for blogs (built-in features)
Cons:
- ❌ Go templating (less familiar than JavaScript)
Best for: Simple, fast blogs with minimal maintenance Learning curve: Easy-Medium Matches your: [Simplicity preference, performance needs]
My Recommendation: [Framework] because [specific reason].
Question: Which framework appeals to you?"
Wait for user answer.
Step 3: Generate Questionnaire File
After 2-3 critical questions answered, generate TECH_REQ_QUESTIONS.md for remaining decisions.
Inform User: "Great! Based on your choices:
- Architecture: [Choice]
- Cloud: [Choice]
- Framework: [Choice]
I'll now generate a questionnaire for the remaining technical decisions. You can answer these at your own pace.
Generating: TECH_REQ_QUESTIONS.md..."
Generate Questionnaire:
# Technical Requirements Questionnaire
**Project**: [Project name from PRD]
**Date**: [Current date]
**Your Decisions So Far**:
- Architecture: [Architecture choice]
- Cloud Provider: [Cloud choice]
- Framework: [Framework choice]
---
## Instructions
- Replace `[YOUR ANSWER]` with your response
- For multiple choice, select one option or write your own
- Feel free to add notes/context
- **Save this file and run**: `/tech-req --process TECH_REQ_QUESTIONS.md`
---
## Section 1: Styling Approach
Based on your [framework choice], here's what works well:
**Q1.1: CSS Framework**
- [ ] Tailwind CSS - Utility-first, rapid development, great for clean designs
- [ ] Custom CSS - Full control, more time-consuming, learning opportunity
- [ ] [Other]: [Specify if you have a preference]
**Your Choice**: [YOUR ANSWER]
**Q1.2: Why this choice?**
[YOUR ANSWER - Optional]
---
## Section 2: Content Management
**Q2.1: How will you manage content?**
Based on [single author/team size]:
- [ ] Git-based (Markdown files) - Version controlled, developer-friendly
- [ ] Headless CMS (Contentful, Strapi) - Web interface, $20-50/month
- [ ] [Other]: [Specify]
**Your Choice**: [YOUR ANSWER]
**Q2.2: Content workflow preference**
If Git-based: Will you write locally and push, or prefer a web editor?
[YOUR ANSWER]
---
## Section 3: Infrastructure Details
**Q3.1: Specific [Cloud] Services**
For [architecture] on [cloud provider], recommend:
- [ ] [Recommended service stack A] - Simple, managed, ~$[X]/month
- [ ] [Recommended service stack B] - More control, ~$[Y]/month
- [ ] [Other]: [Specify if you have preferences]
**Your Choice**: [YOUR ANSWER]
**Q3.2: Domain Setup**
- [ ] I have a domain: [YOUR DOMAIN NAME]
- [ ] Need to register a domain
- [ ] Will decide later
**Your Choice**: [YOUR ANSWER]
---
## Section 4: Database (if data storage needed)
[Only include if PRD indicated data storage needs]
Based on your data needs ([type and volume from PRD]):
- [ ] [Recommended DB option 1] - [Why it fits]
- [ ] [Recommended DB option 2] - [Alternative if X]
- [ ] [Other]: [Specify]
**Your Choice**: [YOUR ANSWER]
---
## Section 5: Authentication (if needed)
[Only include if PRD indicated auth needs]
For [single/multiple users]:
- [ ] [Managed auth provider] - $0-50/month, handles complexity
- [ ] [Simple auth approach] - Build yourself, more control
- [ ] [Other]: [Specify]
**Your Choice**: [YOUR ANSWER]
---
## Section 6: CI/CD & Deployment
**Q6.1: Deployment Automation**
- [ ] Automated (GitHub Actions deploys on git push) - Recommended
- [ ] Manual (run deploy script when ready) - Simple, more control
- [ ] [Other]: [Specify]
**Your Choice**: [YOUR ANSWER]
**Q6.2: Deployment frequency**
How often will you deploy updates?
- [ ] Multiple times per day
- [ ] Few times per week
- [ ] Once per week or less
**Your Choice**: [YOUR ANSWER]
---
## Section 7: Monitoring & Analytics (Optional)
**Q7.1: Do you need analytics/monitoring?**
- [ ] Yes - Basic (page views, visitors)
- [ ] Yes - Advanced (user behavior, funnels, performance)
- [ ] No - Not needed initially
- [ ] Undecided
**Your Choice**: [YOUR ANSWER]
If yes, any preferences?
[YOUR ANSWER]
---
## Section 8: Additional Requirements
**Q8.1: Any other technical requirements or concerns?**
Examples: SEO needs, accessibility requirements, integrations, etc.
[YOUR ANSWER]
---
## Ready to Generate Tech-Req!
Once you've answered these questions, run:
```bash
/tech-req --process TECH_REQ_QUESTIONS.md
```
This will generate your comprehensive TECH_REQ.md document with all technology decisions documented and explained.
**Save file as**: `TECH_REQ_QUESTIONS.md`
**Tell User**:
"✅ Generated `TECH_REQ_QUESTIONS.md` with [N] questions.
Take your time answering these. When ready, run:
`/tech-req --process TECH_REQ_QUESTIONS.md`
This will generate your final `TECH_REQ.md` document."
---
## Questionnaire Processing
When user runs: `/tech-req --process TECH_REQ_QUESTIONS.md`
### Step 1: Read and Parse Answers
Read `TECH_REQ_QUESTIONS.md` and extract all `[YOUR ANSWER]` responses.
**Validation**:
- Check all required questions are answered
- If any missing, prompt: "Please answer Question X.Y before I can proceed."
### Step 2: Generate TECH_REQ.md
Create comprehensive technical requirements document:
```markdown
# Technical Requirements Document: [Project Name]
**Created**: [Date]
**Version**: 1.0
**Status**: Ready for Implementation
**Related Documents**: PRD.md
---
## Executive Summary
[2-3 sentence overview of technical approach based on architecture, cloud, and framework choices]
**Key Decisions**:
- Architecture: [Architecture] - [One line rationale]
- Cloud: [Provider] - [One line rationale]
- Framework: [Framework] - [One line rationale]
- Estimated Monthly Cost: ~$[X]
---
## Architecture Decision
### Pattern Chosen: [Architecture]
**Rationale**:
[2-3 paragraphs explaining why this architecture was chosen based on PRD requirements and user answers]
**Key characteristics**:
- [Characteristic 1 relevant to their project]
- [Characteristic 2]
- [Characteristic 3]
**System Components**:
[Simple ASCII diagram or description of main components] Example for SSG: User → CloudFront (CDN) → S3 (Static Files) Developer → Git Push → GitHub Actions → Build → S3
**Trade-offs Accepted**:
- ✅ Gaining: [What this architecture provides]
- ⚠️ Accepting: [What limitations we're accepting and why they're okay]
---
## Technology Stack
### [Framework Category]: [Chosen Framework]
**Rationale**: [Why this framework based on requirements]
**Alternatives Considered**:
- [Alt 1]: Not chosen because [reason]
- [Alt 2]: Not chosen because [reason]
**Key Features We'll Use**:
- [Feature 1]: [How it helps the project]
- [Feature 2]: [How it helps the project]
### Styling: [Choice]
**Rationale**: [Why this styling approach]
### Content Management: [Choice]
**Workflow**: [Describe the content creation workflow based on answer]
**Tools Needed**:
- [Tool 1]: [Purpose]
- [Tool 2]: [Purpose]
---
## Infrastructure
### Cloud Platform: [Provider]
**Services to Use**:
- **[Service 1]**: [Purpose and configuration]
- **[Service 2]**: [Purpose and configuration]
- **[Service 3]**: [Purpose and configuration]
**Architecture Diagram**:
[Service-level architecture showing how cloud services connect]
### Domain: [Status from questionnaire]
[If domain exists]: Using [domain name]
[If needs registration]: Will register through [recommended registrar]
### CI/CD Pipeline
**Approach**: [Automated/Manual from questionnaire]
[If automated]:
**Pipeline Steps**:
1. Developer commits code → Git push
2. GitHub Actions triggered
3. Build [framework] site
4. Run tests (if applicable)
5. Deploy to [cloud service]
6. Invalidate cache (if CDN)
7. Verify deployment
**Estimated Deploy Time**: [X] minutes per deployment
[If manual]:
**Deployment Process**:
1. Run build locally: `[build command]`
2. Deploy via CLI: `[deploy command]`
3. Verify in browser
---
## Data & Authentication
[Only include sections if applicable based on PRD and questionnaire]
### Database: [If applicable]
**Choice**: [Database]
**Rationale**: [Why this database for their data needs]
**Schema Overview**: [Key tables/collections]
### Authentication: [If applicable]
**Approach**: [Chosen auth method]
**Provider**: [If using managed service]
**Rationale**: [Why this approach]
---
## Monitoring & Analytics
[Based on questionnaire answer]
**Approach**: [Choice from questionnaire]
[If selected analytics]:
**Tools**:
- [Tool]: [Purpose]
**Key Metrics to Track**:
- [Metric 1]
- [Metric 2]
---
## Performance & Scalability
### Performance Targets
Based on PRD requirements:
- **Page Load Time**: [Target from PRD or < 2s default]
- **Time to First Byte**: [Target]
- **API Response Time**: [Target if applicable]
### Scalability Plan
**Phase 1** (Launch - [X] users):
[Initial setup sufficient for early users]
**Phase 2** ([X-Y] users):
[What changes when traffic increases]
**Phase 3** ([Y+] users):
[Scaling approach for higher traffic]
**Cost Projection**:
- Phase 1: ~$[X]/month
- Phase 2: ~$[Y]/month
- Phase 3: ~$[Z]/month
---
## Cost Estimation
### Monthly Infrastructure Costs
**Itemized Breakdown**:
- [Service/Component 1]: $[X]
- [Service/Component 2]: $[Y]
- [Service/Component 3]: $[Z]
- **Total**: ~$[Sum]/month
**Cost Variables**:
- Traffic-dependent: [What costs scale with traffic]
- Fixed: [What costs are constant]
**Optimization Opportunities**:
- [Way to reduce costs if needed]
- [Alternative if budget changes]
---
## Technology Decision Summary
| Decision Category | Chosen Technology | Rationale | Alternatives Considered |
|------------------|-------------------|-----------|------------------------|
| Architecture | [Choice] | [One sentence] | [List] |
| Cloud Provider | [Choice] | [One sentence] | [List] |
| Framework | [Choice] | [One sentence] | [List] |
| Styling | [Choice] | [One sentence] | [List] |
| Content Mgmt | [Choice] | [One sentence] | [List] |
| Database | [Choice/N/A] | [One sentence] | [List] |
| Authentication | [Choice/N/A] | [One sentence] | [List] |
| CI/CD | [Choice] | [One sentence] | [List] |
---
## Implementation Roadmap
### Phase 1: Foundation (Week 1-2)
- [ ] Set up [cloud] account and configure services
- [ ] Initialize [framework] project
- [ ] Configure [styling approach]
- [ ] Set up development environment
- [ ] Create hello-world deployment
### Phase 2: Core Features (Week 3-4)
- [ ] Implement [key feature 1 from PRD]
- [ ] Implement [key feature 2 from PRD]
- [ ] Set up [content management]
- [ ] Configure CI/CD pipeline
### Phase 3: Polish & Launch (Week 5-6)
- [ ] Performance optimization
- [ ] SEO configuration
- [ ] Testing and bug fixes
- [ ] Domain setup and SSL
- [ ] Launch! 🚀
---
## Risks & Mitigation
| Risk | Likelihood | Impact | Mitigation |
|------|------------|--------|------------|
| [Tech Risk 1] | [H/M/L] | [H/M/L] | [How to mitigate] |
| [Cost Risk] | [H/M/L] | [H/M/L] | [How to mitigate] |
| [Scaling Risk] | [H/M/L] | [H/M/L] | [How to mitigate] |
---
## Open Questions
- [ ] [Any remaining technical questions]
- [ ] [Decisions that need prototyping]
---
## Next Steps
1. **Review this document** - Does everything make sense? Any concerns?
2. **Prototype (Optional)** - Try [framework] with a hello-world if unfamiliar
3. **Begin Implementation**:
- Option A: Direct implementation
- Option B: Use EPCC workflow - `/epcc-explore` to analyze patterns and start coding
4. **Set up infrastructure** - Follow Phase 1 of Implementation Roadmap
---
## Appendix: Useful Resources
### Documentation Links
- [Framework]: [Official docs URL]
- [Cloud Provider]: [Getting started guide]
- [Key Tool/Service]: [Tutorial]
### Example Projects
- [Similar project 1]: [Why it's relevant]
- [Similar project 2]: [Why it's relevant]
### Community Resources
- [Forum/Discord]: [Link]
- [Stack Overflow Tag]: [Link]
---
**Technical Requirements Complete!** Ready to build 🚀
Save as: TECH_REQ.md
After Generation
Tell User:
"✅ Tech-Req Complete! Generated TECH_REQ.md with your complete technical specification.
Key Decisions:
- Architecture: [Choice]
- Cloud: [Provider]
- Framework: [Framework]
- Estimated Cost: ~$[X]/month
Next Steps:
- Review TECH_REQ.md - Make sure everything aligns with your vision
- Start Building:
- Direct implementation using the roadmap in TECH_REQ.md
- OR use
/epcc-exploreto analyze existing patterns and start EPCC workflow
The technical foundation is set - time to build!"
Smart Filtering Rules Reference
Budget-Based Filtering
- < $10/month: Show managed/PaaS options, skip enterprise services
- $10-50/month: Show PaaS + basic cloud setups
- > $50/month: Show all options including complex architectures
Scale-Based Filtering
- < 1k users: Skip microservices, show monolithic/serverless/SSG
- 1k-10k users: Show most architectures except microservices
- > 10k users: Show all including microservices
Complexity-Based Filtering
- Beginner: Show managed services, simple frameworks, PaaS
- Intermediate: Show most options
- Advanced: Show all including custom infrastructure
Use Case-Based Filtering
- Blog/Documentation: Show only SSG + JAMstack
- Internal Tool (< 10 users): Show monolithic + serverless
- SaaS Application: Show SSR + Microservices + Hybrid
- E-commerce: Show SSR + Hybrid (need dynamic + static)
Example Filtered Question
Bad (Information Overload):
Here are 5 architecture options: Monolithic (pros: A, B, C, cons: D, E, F),
Microservices (pros: G, H, I, cons: J, K, L), Serverless (pros: M, N, O, cons: P, Q, R),
JAMstack (pros: S, T, U, cons: V, W, X), Hybrid (pros: Y, Z, AA, cons: BB, CC, DD)...
👎 User has to process 15 pros + 15 cons = 30 points before answering
Good (Smart Filtered):
Based on your single-author blog with < 1k users, here are the 2 best options:
Option 1: Static Site Generator
✅ Maximum performance, ✅ Minimal cost ($2-5/month), ✅ Perfect for blogs
❌ No dynamic features
Option 2: JAMstack
✅ Static performance + some dynamic features, ✅ Cost-effective
❌ More complex than pure SSG
Recommendation: SSG - matches your use case perfectly.
Which appeals to you?
👍 User processes 4 pros + 2 cons = 6 points, makes decision quickly
Agents 2
../../agile-tools/agents/business-analyst.md
../../code-analysis/agents/tech-evaluator.md
Sponsors
Details
- Marketplace
- aws-solutions-library-samples/guidance-for-claude-code-with-amazon-bedrock
- Source
- assets/claude-code-plugins/plugins/requirements
- Category
- Workflow