Master Context Template for Large Projects:
==========================================

PROJECT OVERVIEW:
- System architecture: [Microservices/Monolith/Hybrid]
- Tech stack: [Complete technology inventory]
- Business domain: [Specific industry/problem space]
- Scale requirements: [Users, data volume, performance]
- Compliance needs: [Security, regulatory requirements]

CURRENT DEVELOPMENT PHASE:
- Sprint goals: [Specific objectives]
- Dependencies: [External services, team dependencies]
- Constraints: [Time, resource, technical limitations]
- Success criteria: [Measurable outcomes]

CODEBASE CONTEXT:
- Architecture patterns: [Clean Architecture, DDD, etc.]
- Coding standards: [Link to style guide]
- Testing strategy: [Unit, integration, e2e approaches]
- Performance benchmarks: [Current metrics and targets]

TECHNICAL DEBT INVENTORY:
- Known issues: [Documented technical debt]
- Refactoring priorities: [What needs improvement]
- Legacy constraints: [Systems that can't be changed]

Foundation (persisted in CLAUDE.md):
- Complete architecture documentation
- Coding standards and patterns
- Business domain knowledge

Session (prepared at start):
- Current feature requirements
- Relevant code modules
- Specific constraints for this work

Interaction (provided with each request):
- Specific task details
- Expected deliverables
- Success criteria

Session Plan Template:
=====================
Session Goal: [Overarching objective]
Estimated Duration: [Time allocation]
Milestones: [Checkpoints for progress validation]
Dependencies: [What needs to be completed first]
Deliverables: [Specific outputs expected]
Rollback Points: [Where to return if issues arise]

Decision Log for Session:
========================
1. Chose Redis over Memcached for caching (performance requirements)
2. Implemented repository pattern for data access (testability)
3. Used dependency injection for service integration (flexibility)
4. Applied Command pattern for complex operations (audit trail)

"Before we continue, let me summarize our progress:
- Completed: User service with authentication
- Current: Working on notification system integration  
- Next: Payment processing workflow
- Key constraints: Must maintain < 200ms response time
- Architecture decisions: Using event-driven pattern for notifications"

Project Structure Analysis:
===========================
Core Services:
- user_service.py: [Authentication, user management]
- notification_service.py: [Email, SMS, push notifications]
- payment_service.py: [Billing, subscription management]

Data Layer:
- models.py: [SQLAlchemy models, relationships]
- repositories.py: [Data access patterns]
- migrations/: [Database version control]

API Layer:
- api/users.py: [User endpoints, depends on user_service]
- api/notifications.py: [Notification endpoints]
- api/payments.py: [Payment endpoints]

Integration Points:
- User creation triggers notification setup
- Payment events trigger user status updates
- Notifications depend on user preferences

Multi-File Refactoring Plan:
============================
Phase 1: Interface Changes
- Update base service interfaces
- Modify abstract classes
- Adjust dependency injection contracts

Phase 2: Implementation Updates  
- Refactor concrete service implementations
- Update repository patterns
- Modify data access layers

Phase 3: API Layer Updates
- Adjust controller methods
- Update request/response models
- Modify endpoint configurations

Phase 4: Integration Testing
- Verify all interfaces work correctly
- Test cross-service communication
- Validate end-to-end workflows

Complex Task: "Build a user notification microservice with email, SMS, and push capabilities"

Decomposition:
==============
LEVEL 1: High-level components
1. Data model and storage layer
2. Notification service interfaces
3. Provider implementations (email, SMS, push)
4. API endpoints and routing
5. Configuration and deployment

LEVEL 2: Detailed subtasks for each component
1.1. User notification preferences model
1.2. Notification template system
1.3. Delivery tracking and status
1.4. Database migrations and indexes

2.1. Abstract notification service interface
2.2. Factory pattern for provider selection
2.3. Retry mechanism for failed deliveries
2.4. Rate limiting implementation

[Continue for all components...]

LEVEL 3: Implementation sequence
- Dependencies between tasks
- Integration points requiring coordination
- Testing strategies for each component
- Rollback procedures if issues arise

Dependency Graph:
================
Task 1 (Data Models) → Must complete before Tasks 2, 4
Task 2 (Service Interfaces) → Enables Tasks 3, 4
Task 3 (Provider Implementation) → Depends on Task 2
Task 4 (API Endpoints) → Depends on Tasks 1, 2
Task 5 (Configuration) → Can run parallel to Tasks 1-4

Critical Path: 1 → 2 → 3 → Integration Testing
Secondary Path: 1 → 4 → API Testing
Parallel Path: 5 (Configuration setup)

Step 1 Context Summary:
======================
Completed: User model with notification preferences
Decisions: Used JSON field for preference storage (flexibility)
Patterns: Repository pattern with dependency injection
Testing: 95% coverage with integration tests
Next: Build service layer using established patterns

Step 2 Context Inheritance:
===========================
Building on Step 1 patterns:
- Continue repository pattern for consistency
- Use same dependency injection approach
- Maintain 95% test coverage standard
- Apply JSON preference handling from Step 1

Checkpoint Template:
===================
What we've built: [Completed components]
Quality validation: [Tests passing, standards met]
Integration status: [How components work together]
Remaining work: [Next steps and dependencies]
Risk assessment: [Potential issues and mitigation]

Multi-Step Quality Gates:
========================
Gate 1 (After each major component):
- [ ] Unit tests pass with >90% coverage
- [ ] Integration with previous components verified
- [ ] Code review standards met
- [ ] Performance benchmarks within targets

Gate 2 (After integration points):
- [ ] End-to-end workflows function correctly
- [ ] Error handling works across component boundaries
- [ ] Data consistency maintained throughout system
- [ ] Security requirements validated

Gate 3 (Before milestone completion):
- [ ] Full system integration testing
- [ ] Performance under load testing
- [ ] Security vulnerability scanning
- [ ] Documentation complete and accurate

Consistency Checklist:
=====================
Code Style:
- [ ] Naming conventions consistent across all files
- [ ] Error handling patterns uniform throughout
- [ ] Logging format standardized
- [ ] Documentation style maintained

Architecture:
- [ ] Design patterns applied consistently
- [ ] Dependency injection used uniformly
- [ ] Database access patterns standardized
- [ ] API design conventions followed

Testing:
- [ ] Test structure consistent across modules
- [ ] Mock usage patterns standardized
- [ ] Integration test approach uniform
- [ ] Performance test methodology consistent

Expert Prompt Structure:
=======================
"Design a [component] that satisfies these constraints:

HARD REQUIREMENTS (must be met):
- Performance: Must handle X requests/second
- Scalability: Support Y concurrent users
- Security: Implement Z security measures
- Compliance: Meet regulation A, B, C

SOFT PREFERENCES (optimize for):
- Maintainability over performance where trade-offs exist
- Prefer established patterns over novel approaches
- Optimize for team familiarity with technology choices
- Balance complexity vs. functionality

ANTI-PATTERNS (explicitly avoid):
- Don't use pattern X (explain why)
- Avoid technology Y for this use case
- Prevent architectural decision Z

CONTEXT DEPENDENCIES:
- Must integrate with existing system A
- Share data model with component B
- Follow established pattern C from our codebase

"Compare these architectural approaches for [problem]:

OPTION 1: [Specific approach]
OPTION 2: [Alternative approach]
OPTION 3: [Third alternative]

For each option, analyze:
1. Performance implications under our load requirements
2. Maintenance overhead for our team size and skill level
3. Scalability characteristics for our growth projections
4. Integration complexity with our existing systems
5. Risk factors and mitigation strategies

Provide a recommendation with justification based on our specific constraints: [list constraints]"

"Provide the solution in this exact structure:

SECTION 1: IMPLEMENTATION
- Complete, production-ready code
- Include all necessary imports and dependencies
- Add inline comments for complex logic
- Follow our coding standards: [specific guidelines]

SECTION 2: TESTING STRATEGY  
- Unit tests with >90% coverage
- Integration test examples
- Performance test scenarios
- Error condition validations

SECTION 3: DEPLOYMENT CONSIDERATIONS
- Configuration requirements
- Environment variables needed
- Database migration scripts
- Monitoring and alerting recommendations

SECTION 4: MAINTENANCE GUIDE
- Common troubleshooting scenarios
- Performance optimization opportunities
- Future enhancement considerations
- Documentation updates needed"

"Implement with these quality requirements:

CODE QUALITY:
- Cyclomatic complexity < 10 per function
- No functions longer than 50 lines
- Maximum nesting depth of 3 levels
- All public methods must have docstrings

PERFORMANCE:
- Database queries optimized (no N+1 problems)
- Caching strategy for frequently accessed data
- Async/await for I/O operations where appropriate
- Memory usage profiling considerations

SECURITY:
- Input validation on all user data
- SQL injection prevention
- Authentication/authorization checks
- Sensitive data encryption requirements

MAINTAINABILITY:
- Clear separation of concerns
- Dependency injection for testability
- Configuration externalized from code
- Comprehensive error messages for debugging"

Iteration Cycle:
===============
1. INITIAL SOLUTION REQUEST
   - Provide comprehensive requirements
   - Request complete implementation
   - Ask for architectural justification

2. CRITICAL ANALYSIS
   - "What are the weaknesses of this approach?"
   - "Where might this fail under load?"
   - "What edge cases are not handled?"

3. TARGETED IMPROVEMENTS
   - "Improve the error handling for scenario X"
   - "Optimize performance for use case Y"
   - "Add resilience for failure mode Z"

4. INTEGRATION VALIDATION
   - "How does this integrate with our existing system A?"
   - "What changes are needed in component B?"
   - "Are there any breaking changes for API consumers?"

5. PRODUCTION READINESS
   - "What monitoring should we add?"
   - "How do we handle deployment rollback?"
   - "What documentation updates are needed?"

"Let's improve this implementation systematically:

ROUND 1: Correctness and completeness
- Review for logical errors or missing functionality
- Ensure all requirements are fully addressed
- Validate error handling for all failure modes

ROUND 2: Performance optimization  
- Identify bottlenecks and optimization opportunities
- Optimize database queries and data access patterns
- Implement appropriate caching strategies

ROUND 3: Production hardening
- Add comprehensive monitoring and logging
- Implement circuit breakers and retry logic
- Add configuration validation and startup checks

ROUND 4: Maintainability enhancement
- Improve code documentation and comments
- Add debugging hooks and diagnostic information
- Create troubleshooting guides and runbooks"

Automated Code Generation Pipeline:
==================================
1. TRIGGER: Pull request or scheduled maintenance
2. CONTEXT PREPARATION: Automated gathering of:
   - Current codebase state
   - Performance benchmarks
   - Technical debt inventory
   - Planned feature requirements

3. AI-ASSISTED ANALYSIS: 
   - Code quality assessment
   - Performance optimization suggestions  
   - Security vulnerability analysis
   - Refactoring recommendations

4. HUMAN REVIEW GATE:
   - Technical lead reviews AI suggestions
   - Business stakeholder validates requirements alignment
   - Security team approves security-related changes

5. AUTOMATED IMPLEMENTATION:
   - Generate code using approved AI recommendations
   - Run comprehensive test suite
   - Performance benchmark validation
   - Deploy to staging environment for validation

Automated Documentation Pipeline:
================================
INPUT: Code changes from development team
PROCESS: AI analysis and documentation generation
OUTPUT: Updated technical documentation

Documentation Types Generated:
- API documentation with examples
- Architecture decision records
- Troubleshooting guides
- Performance tuning recommendations
- Security configuration guides

Modernization Pipeline:
======================
PHASE 1: Assessment
- AI analysis of legacy code complexity
- Identification of modernization priorities  
- Risk assessment for business continuity
- Resource requirement estimation

PHASE 2: Planning
- AI-generated modernization roadmap
- Dependency analysis and sequencing
- Testing strategy for legacy behavior preservation
- Rollback procedure development

PHASE 3: Implementation
- AI-assisted refactoring with safety checks
- Automated test generation for behavior validation
- Performance benchmark comparison
- Documentation updates for new patterns

PHASE 4: Validation
- Comprehensive testing of modernized components
- Performance validation against benchmarks
- Business logic verification
- User acceptance testing coordination

Architecture Evolution Process:
==============================
TRIGGER: Business requirement changes or scale demands
ANALYSIS: AI-powered architecture assessment
DESIGN: Collaborative architecture design (AI + human experts)
PLANNING: Implementation roadmap with risk mitigation
EXECUTION: Phased implementation with continuous validation
MONITORING: Performance and reliability tracking post-implementation

Systematic Performance Enhancement:
==================================
BASELINE ESTABLISHMENT:
- Current performance metrics across all system components
- User experience benchmarks and expectations  
- Resource utilization patterns and bottlenecks
- Cost analysis for infrastructure and maintenance

AI-ASSISTED ANALYSIS:
- Hotspot identification in code and infrastructure
- Algorithmic complexity analysis and optimization suggestions
- Database query optimization recommendations
- Caching strategy improvements

OPTIMIZATION IMPLEMENTATION:
- Prioritized performance improvements based on impact
- A/B testing for optimization validation
- Gradual rollout with monitoring and rollback procedures
- Continuous performance monitoring and alerting

VALIDATION AND MONITORING:
- Performance benchmark comparison (before/after)
- User experience impact assessment
- Cost-benefit analysis of optimizations
- Long-term performance trend monitoring

Edge Case Identification Process:
================================
BUSINESS EDGE CASES:
- Unusual user behavior patterns
- Regulatory compliance exceptions
- Data corruption recovery scenarios
- Third-party service failure modes

TECHNICAL EDGE CASES:
- Boundary value testing requirements
- Concurrency and race condition scenarios
- Memory and resource exhaustion conditions
- Network failure and timeout handling

SCALABILITY EDGE CASES:
- Extreme load conditions
- Data volume growth scenarios
- Geographic distribution challenges
- Multi-tenancy isolation requirements

SECURITY EDGE CASES:
- Attack vector considerations
- Data privacy boundary conditions
- Authentication failure cascades
- Authorization edge cases and privilege escalation

Complex Requirement Analysis:
============================
"We have an unusual requirement: [describe specific requirement]

Please analyze this from multiple angles:

FEASIBILITY ASSESSMENT:
- Technical implementation challenges
- Performance implications
- Security considerations
- Maintenance overhead

ALTERNATIVE APPROACHES:
- Standard industry solutions
- Custom implementation options
- Third-party tool integration possibilities
- Hybrid approach combinations

RISK ANALYSIS:
- Implementation risks and mitigation strategies
- Operational risks and monitoring needs
- Business continuity considerations
- Rollback and recovery procedures

RECOMMENDATION:
- Preferred approach with detailed justification
- Implementation roadmap and milestones
- Success criteria and validation methods
- Long-term maintenance considerations"

AI Code Debugging Framework:
============================
LEVEL 1: Logical Validation
- Trace through AI logic step by step
- Verify algorithm correctness for edge cases
- Validate data flow and state management
- Check error handling completeness

LEVEL 2: Integration Analysis  
- Test interactions with existing systems
- Validate API contract compliance
- Check database transaction consistency
- Verify security policy enforcement

LEVEL 3: Performance Profiling
- Measure actual vs. expected performance
- Identify bottlenecks and resource usage
- Validate scalability under load
- Check memory leaks and resource cleanup

LEVEL 4: Production Behavior
- Monitor real-world usage patterns
- Analyze error logs and failure modes
- Track business metric impacts
- Gather user feedback and experience data

Python-Specific Claude Code Optimization:
=========================================
PERFORMANCE PATTERNS:
- Use list comprehensions over loops where appropriate
- Implement generators for memory efficiency with large datasets
- Leverage async/await for I/O-bound operations
- Apply caching with functools.lru_cache for expensive computations

PYTHON IDIOMS:
- Follow PEP 8 style guidelines
- Use context managers for resource management
- Implement proper exception handling with specific exception types
- Utilize type hints for better code documentation and IDE support

FRAMEWORK INTEGRATION:
- Django: Follow MVT pattern, use Django ORM efficiently
- FastAPI: Leverage dependency injection and automatic documentation
- Flask: Implement blueprints for modular architecture
- SQLAlchemy: Use lazy loading and query optimization

JavaScript/TypeScript Optimization:
==================================
MODERN PATTERNS:
- Use async/await over Promise chains
- Implement proper error boundaries in React
- Leverage TypeScript strict mode for better type safety
- Use modern ES6+ features appropriately

PERFORMANCE CONSIDERATIONS:
- Implement proper memoization for expensive computations
- Use Web Workers for CPU-intensive tasks
- Optimize bundle size with tree shaking
- Implement efficient state management patterns

FRAMEWORK-SPECIFIC:
- React: Use hooks effectively, implement proper key props
- Node.js: Handle streams properly, implement clustering
- Express: Use middleware efficiently, implement proper error handling
- Next.js: Leverage SSR/SSG appropriately for performance

AI Feature Adoption Process:
===========================
MONITORING:
- Follow official Claude Code release notes and updates
- Participate in developer communities and forums
- Track industry trends in AI-assisted development
- Monitor competitor tools and feature comparisons

EVALUATION:
- Test new features in sandbox environments
- Assess impact on existing workflows and productivity
- Evaluate learning curve and training requirements
- Analyze cost-benefit for team adoption

INTEGRATION PLANNING:
- Develop migration strategies for workflow changes
- Plan team training and onboarding for new features
- Update documentation and best practices
- Coordinate rollout timing with project schedules

ADOPTION AND OPTIMIZATION:
- Gradual rollout with feedback collection
- Optimization of workflows using new capabilities
- Documentation of lessons learned and best practices
- Knowledge sharing across development teams

AI Evolution Preparedness:
=========================
SKILL DEVELOPMENT:
- Maintain fundamental programming skills alongside AI usage
- Develop critical thinking for AI output evaluation
- Build expertise in prompt engineering and AI interaction
- Stay current with software architecture and design principles

WORKFLOW FLEXIBILITY:
- Design workflows that can incorporate new AI capabilities
- Maintain documentation for easy workflow updates
- Build team processes that adapt to changing tool capabilities
- Establish feedback loops for continuous improvement

KNOWLEDGE MANAGEMENT:
- Document successful patterns and techniques
- Build institutional knowledge beyond individual expertise
- Create training materials that evolve with AI capabilities
- Establish mentoring programs for AI-assisted development

STRATEGIC POSITIONING:
- Anticipate future AI development trends
- Invest in complementary skills (architecture, design, product thinking)
- Build competitive advantages through advanced AI usage
- Prepare for increased AI integration across development lifecycle

Sustainable AI Workflow Design:
==============================
MODULAR APPROACH:
- Design workflows with interchangeable AI components
- Separate AI-specific logic from business logic
- Create abstractions that hide AI implementation details
- Build fallback procedures for AI service disruptions

DOCUMENTATION STANDARDS:
- Document AI decision points and reasoning
- Maintain version history of AI-generated code
- Record successful prompting patterns and techniques
- Create runbooks for AI workflow troubleshooting

QUALITY ASSURANCE:
- Implement automated testing for AI-generated components
- Establish code review standards for AI-assisted development
- Create performance benchmarks for AI workflow outcomes
- Build monitoring and alerting for AI workflow health

CONTINUOUS IMPROVEMENT:
- Regular retrospectives on AI workflow effectiveness
- A/B testing of different AI approaches and techniques
- Knowledge sharing sessions within and across teams
- Investment in training and skill development for team members