AI Prompt Playbooks

I need to extract and structure business context from the following information: [PASTE: Meeting notes, emails, strategy documents, stakeholder conversations] Please extract and structure this into a BVDLC Phase 0 artifact with: 1. **Core Business Problem** (2 sentences max) - What's broken and why it matters - Root cause, not just symptoms 2. **Target Users/Stakeholders** - Who is affected by this problem - Who benefits from solving it 3. **Success Metrics with Specific Targets** - Primary KPI: Current baseline → Target value by [date] - Secondary KPIs (if applicable) - How we'll measure success 4. **Constraints and Non-Negotiables** - Technical constraints - Business constraints (budget, timeline, resources) - Compliance/regulatory requirements 5. **Timeline and Dependencies** - Critical dates - External dependencies - Market/competitive pressures 6. **Stakeholder Expectations** - What does the executive sponsor expect? - What are the key concerns? 7. **Risk Register** - What could go wrong? - How likely? How severe? - Mitigation strategies Format this as a structured document that AI can consume in subsequent phases. Make it specific and measurable—no vague goals.

**Phase 0 Business Context:** - Problem: [BUSINESS PROBLEM FROM PHASE 0] - Target Users: [WHO THIS IS FOR] - Success Metrics: [PRIMARY KPI TO MOVE] - Constraints: [KEY CONSTRAINTS] ***Task:** Build a working prototype that proves feasibility and validates value hypothesis. Build a working prototype that: 1. Demonstrates the core value proposition 2. Uses real or realistic data (not dummy data) 3. Can be tested with actual users 4. Can be built in < 4 hours 5. Proves technical feasibility **Technology Stack:** [SPECIFY IF KNOWN, OR ASK AI TO RECOMMEND] **Prototype Requirements:** - Must solve: [CORE PROBLEM] - Must include: [MINIMUM FEATURES] - Must prove: [KEY ASSUMPTIONS] **Also Generate:** 1. Working prototype code 2. Setup/deployment instructions 3. User testing script with questions 4. Success criteria for validation Make this fast and rough—we're validating direction, not building production quality.

**Phase 0 Business Context:** [PASTE: Business problem, success metrics, constraints from Phase 0] **Phase 1 Prototype Results:** [PASTE: What we built, what we learned, user feedback summary] **Validated Approach:** - Prototype demonstrated: [WHAT WORKED] - Users confirmed: [VALUE VALIDATION] - Technical learnings: [WHAT WE DISCOVERED] Now design a PRODUCTION-READY architecture based on this validated prototype: 1. **System Architecture** - High-level component diagram - Services and their responsibilities - Data stores and schemas - Integration points with existing systems 2. **Security Hardening** - Vulnerabilities identified in prototype - Recommended security patterns - Authentication/authorization approach - Data protection strategy - Compliance requirements (from Phase 0) 3. **Performance Optimization** - Bottlenecks identified in prototype - Scaling strategy (horizontal/vertical) - Caching approach - Database optimization - Target performance metrics 4. **Integration Mapping** - External system connections - API contracts and specifications - Data flows and transformations - Error handling and retry logic 5. **Non-Functional Requirements** - Availability targets (e.g., 99.9% uptime) - Performance targets (response time, throughput) - Scalability requirements - Disaster recovery approach 6. **Technology Stack** - Final technology choices with rationale - Why this stack serves Phase 0 objectives - Migration path from prototype (if different) 7. **Deployment Architecture** - Infrastructure requirements - Environment strategy (dev/staging/prod) - Cost projections - Operational considerations Output: Production-ready architecture blueprint that: - Builds on validated prototype approach - Addresses all gaps found during prototyping - Meets Phase 0 business requirements - Can be built by the team in [TIMELINE] - Is maintainable by [OPERATIONS TEAM] Format as structured markdown with diagrams (Mermaid format).

Document this architecture decision using the ADR format: **Decision Context:** - Phase 0 Business Requirement: [WHAT BUSINESS NEED DRIVES THIS] - Phase 1 Learnings: [WHAT PROTOTYPE TAUGHT US] - Technical Challenge: [WHAT PROBLEM ARE WE SOLVING] **Decision:** [WHAT WE'RE DECIDING] **Options Considered:** **Option 1: [NAME]** - Description: [HOW THIS WORKS] - Pros: [BENEFITS] - Cons: [TRADE-OFFS] - Estimated complexity: [HIGH/MEDIUM/LOW] - Estimated cost impact: [$AMOUNT OR %] **Option 2: [NAME]** - Description: [HOW THIS WORKS] - Pros: [BENEFITS] - Cons: [TRADE-OFFS] - Estimated complexity: [HIGH/MEDIUM/LOW] - Estimated cost impact: [$AMOUNT OR %] Generate an ADR that: 1. Compares options objectively 2. Recommends best option with clear rationale 3. Explains how recommendation serves Phase 0 business objectives 4. Documents trade-offs we're accepting 5. Defines success criteria for this decision 6. Includes rollback strategy if decision proves wrong Format as: ADR-[NUMBER]-[SHORT-NAME].md

**Phase 0 Business Context:** [PASTE: Business objectives, success metrics, constraints] **Phase 2 Architecture:** [PASTE: System architecture, components, integration points] Generate a comprehensive implementation plan: **1. Component Prioritization** Analyze which components: - Deliver independent value (can be released alone) - Prove Phase 0 hypothesis fastest - Have dependencies that must be built first - Can be built in parallel vs. sequentially Provide prioritized build order with rationale. **2. Task Breakdown for Each Component** For each component, create tasks with: | Task ID | Description | Acceptance Criteria | Input Requirements | Output Specifications | AI Suitable? | Estimated Effort | Dependencies | |---------|-------------|--------------------|--------------------|----------------------|--------------|------------------|--------------| | T-001 | | Functional:
Business Value: | | | Yes/No | [Hours/Days] | [Task IDs] | **Acceptance Criteria Format:** - Functional: What it must do technically - Business Value: How it serves Phase 0 objectives **AI Suitability Assessment:** - **Yes:** Clear specs, well-defined inputs/outputs, AI can generate - **No:** Requires domain expertise, complex business logic, human judgment **3. Execution Strategy** - Parallel work streams: What can be built simultaneously - Critical path: Tasks that block other work - Risk mitigation: How we handle high-risk tasks - Value delivery sequence: Order that delivers business value soonest **4. AI Acceleration Plan** For AI-suitable tasks: - What context AI needs (link to Phase 2 docs) - What prompts to use - What validation humans must do Output: Complete task backlog ready for Phase 4 implementation. Format: Markdown tables + dependency diagram (Mermaid).

**Phase 0 Business Context:** [PASTE: What business problem this code solves] **Phase 2 Architecture:** [PASTE: Relevant architecture design, technology stack, patterns] **Phase 3 Task:** Task ID: [ID] Description: [WHAT TO BUILD] Acceptance Criteria: [FUNCTIONAL + BUSINESS VALUE REQUIREMENTS] Input Requirements: [WHAT THIS NEEDS] Output Specifications: [WHAT THIS PRODUCES] **Technology Stack:** [FROM PHASE 2] **Coding Standards:** [YOUR ORG STANDARDS OR LINK TO STYLE GUIDE] Generate implementation for: [COMPONENT NAME] **Requirements:** 1. **Follow Phase 2 Architecture Exactly** - Use specified design patterns - Adhere to component boundaries - Match integration specifications 2. **Serve Phase 0 Business Objective** - Every function should have a purpose traceable to business value - No over-engineering beyond requirements 3. **Include Comprehensive Error Handling** - Expected errors with user-friendly messages - Unexpected errors with logging and monitoring - Graceful degradation where appropriate 4. **Add Inline Documentation with Business Context** - Document WHY (business reason), not just WHAT (code does) - Include traceability comments to Phase 0/2/3 5. **Create Tests Alongside Code (TDD Approach)** - Unit tests for business logic - Integration tests for external dependencies - Test coverage > 80% for value-critical paths 6. **Ensure Traceability** - Comments linking to Phase 0 objectives - Comments linking to Phase 2 architecture decisions - Comments linking to Phase 3 acceptance criteria Also generate: - Configuration files - Environment variables needed - README with setup instructions and business justification - Integration points documentation

**Phase 0 Business Objectives:** [PASTE: Success metrics, KPIs to move] **Phase 2 NFRs:** [PASTE: Performance targets, security requirements, integration specs] **Phase 4 Implementation:** [PASTE: Brief description of what was built] **Code Location:** [LINK OR PASTE CODE] Generate a comprehensive test suite covering all five quality dimensions: **1. Functional Testing** - Happy path scenarios (expected usage) - Edge cases from Phase 2 architecture - Error conditions and exception handling - User acceptance criteria from Phase 0 **2. Performance Testing** - Load scenarios meeting Phase 2 NFR targets - Stress testing to find breaking points - Resource utilization (memory, CPU, network) - Latency measurements under various loads - Target: [SPECIFY FROM PHASE 2 NFRs] **3. Security Testing** - OWASP Top 10 vulnerability checks - Authentication/authorization validation - Input validation and sanitization - Data protection verification (encryption, PII handling) - Compliance requirements from Phase 0 **4. Integration Testing** - API contracts from Phase 2 - Data flow validation across system boundaries - External system integration points - System boundary testing - Mocking strategies for external dependencies **5. Business Value Testing** - Instrumentation to track Phase 0 KPIs - Accuracy of business metric tracking - Validation that code achieves Phase 0 success criteria - A/B testing setup (if applicable) Output: - Executable test code with clear assertions - Test data setup/teardown scripts - Expected vs. actual results documentation - Coverage report targeting >90% for value-critical paths Format: [YOUR TEST FRAMEWORK - e.g., Jest, pytest, JUnit]

**Phase 0 Business Objectives:** [PASTE: Original KPIs, success metrics, targets] **Phase 4 Deployment:** [PASTE: What was deployed, when, to what scale] Set up continuous value monitoring: **1. Business KPI Tracking** For each Phase 0 KPI, configure: - **Metric:** [KPI NAME] - **Baseline:** [VALUE BEFORE DEPLOYMENT] - **Target:** [PHASE 0 TARGET] - **Current:** [CURRENT VALUE] - **Trend:** [IMPROVING / FLAT / DEGRADING] - **Measurement Method:** [HOW WE TRACK THIS] - **Dashboard Link:** [WHERE TO VIEW] - **Update Frequency:** [REAL-TIME / HOURLY / DAILY / WEEKLY] **2. Value Realization Report Template** Generate weekly report template in markdown format. **3. Feedback Loop Triggers** Define when to trigger feedback to earlier phases: **Trigger Phase 0 Reassessment:** - KPIs degrading > [THRESHOLD]% for [DURATION] - Business assumptions proven wrong - Market conditions changed significantly **Trigger Phase 1 New Feature:** - User requests for specific capability > [THRESHOLD] - Opportunity to improve KPI by [THRESHOLD]% identified - Competitive gap emerged **4. Dashboard Configuration** **Executive Value Dashboard:** - Business KPIs with trend lines - ROI calculation (actual vs. projected) - User adoption metrics - System health summary (traffic light) **Operations Health Dashboard:** - Technical performance metrics - Error rates and incident history - Resource utilization and cost - SLA compliance **5. Alert Rules** **Business Metric Alerts:** - Primary KPI degradation: [THRESHOLD LOGIC] → Notify [STAKEHOLDER] - User adoption below target: [THRESHOLD LOGIC] → Notify [PRODUCT OWNER] - Cost overrun: [THRESHOLD LOGIC] → Notify [FINANCE + ENGINEERING] Output: Complete Phase 5 monitoring configuration