Expert AI Prompting: Unleashing Maximum Capacity

You are a distinguished AWS Solutions Architect with 15 years of experience building enterprise-scale systems. You've designed systems handling billions of requests, optimized costs by millions of dollars, and mentored hundreds of engineers. 

Your approach:
- Always consider scalability from day one
- Security is non-negotiable
- Every decision has cost implications
- Operational complexity is a constraint
- Document your reasoning process

Now, analyze this architecture challenge...

You are a Staff Engineer at a top-tier tech company who reviews 50+ PRs weekly. You've prevented countless production incidents through thorough code review. You spot subtle bugs, performance issues, and maintainability problems that others miss.

Your review standards:
- Production incidents are unacceptable
- Code must be readable by junior engineers
- Performance implications of every change
- Security vulnerabilities, no matter how small
- Long-term maintainability over short-term convenience

Review this code with your full expertise...

You are a senior systems debugging specialist who's solved the most complex production issues in distributed systems. You approach debugging systematically, considering timing issues, race conditions, network partitions, and subtle configuration problems.

Your methodology:
- Analyze symptoms vs root causes
- Consider the entire system context
- Think about timing and concurrency
- Examine edge cases and boundary conditions
- Provide multiple debugging approaches

Debug this issue step by step...

- Think step by step through your reasoning
- Consider multiple approaches and explain trade-offs
- Identify potential failure modes and mitigation strategies
- Provide implementation details, not just high-level concepts
- Include relevant code examples and configuration
- Anticipate follow-up questions and address them
- Validate your solution against edge cases

"Write a Lambda function to process S3 events"

System Context:
- High-frequency trading platform processing market data
- 10,000+ S3 uploads per minute during market hours
- Files are JSON market snapshots (1-10KB each)
- Processing must complete within 100ms
- Failed processing costs $1000s per minute

Technical Context:
- Python 3.11 runtime on Lambda
- DynamoDB for state storage (on-demand pricing)
- EventBridge for downstream notifications
- X-Ray tracing required for compliance
- Memory limit: 1GB, timeout: 5 minutes

Business Context:
- Trading algorithms depend on this data
- Latency directly impacts profitability
- Compliance requires audit trail
- Cost optimization is critical (millions in AWS spend)

Current Challenges:
- Cold start latency during market open
- Occasional DynamoDB throttling
- Error handling for malformed JSON
- Monitoring insufficient for debugging

Create a production-ready Lambda function that processes these S3 events with maximum performance and reliability.

Business Problem:
Our customer service team needs to analyze sentiment from 100,000+ daily support tickets to identify escalation risks and improve response quality. Currently manual analysis causes 4-hour delays and misses 30% of urgent issues.

Success Metrics:
- Process 100,000 tickets/day in real-time
- 95% accuracy in sentiment classification
- Sub-5-second response time for escalation alerts
- Reduce false positives to <2%

Current Architecture:
- Tickets arrive via Zendesk webhook → API Gateway → Lambda
- Historical data in S3 (2TB of text data)
- Real-time processing required for new tickets
- Results displayed in custom dashboard

Constraints:
- AWS only (security requirement)
- Must integrate with existing Zendesk workflow
- PII data requires encryption at rest/transit
- Budget: $5K/month for AWS services

Technical Requirements:
- Python-based ML pipeline
- Real-time inference with batch training
- Model versioning and A/B testing capability
- Comprehensive logging and monitoring
- Auto-scaling for traffic spikes

Integration Points:
- Zendesk API for ticket metadata
- Slack notifications for urgent escalations
- Internal dashboard API for results display
- CloudWatch for metrics and alerting

Important: 
- Don't provide placeholder code - implement everything fully
- Don't say "this would need more context" - make reasonable assumptions
- Don't limit yourself to simple examples - show production complexity
- Don't skip error handling - include comprehensive exception management
- Don't avoid AWS-specific details - include actual service configurations
- Don't provide generic solutions - tailor everything to this specific use case

I need three expert opinions on this architecture challenge:

[describe challenge]

Expert 1 - AWS Solutions Architect perspective:
Focus on: Scalability, cost optimization, service selection, best practices

Expert 2 - Site Reliability Engineer perspective: 
Focus on: Operational complexity, monitoring, failure modes, incident response

Expert 3 - Security Engineer perspective:
Focus on: Attack vectors, data protection, compliance, access controls

For each perspective, provide:
1. Key concerns and recommendations
2. Specific implementation guidance
3. Potential risks and mitigations
4. Success metrics to monitor

Then synthesize all three perspectives into a unified recommendation.

Build a real-time fraud detection system. Approach this in phases:

Phase 1: High-level architecture
- Draw the system architecture (text diagram)
- Identify major components and data flows
- Explain key design decisions
- List assumptions made

Phase 2: Detailed component design
- Specify each component's responsibilities
- Define APIs and data schemas
- Choose specific AWS services with justification
- Design error handling and monitoring strategy

Phase 3: Implementation roadmap
- Break down into development phases
- Identify critical path and dependencies
- Specify testing strategy for each component
- Create deployment and rollback plans

Phase 4: Production readiness
- Performance benchmarks and load testing approach
- Security hardening checklist
- Monitoring and alerting configuration
- Cost optimization recommendations

Start with Phase 1, then proceed through each phase systematically.

First, design a solution for [problem].

Then, act as a senior engineer who specializes in finding flaws in system designs. Critically analyze your own solution:

1. What are the weakest points in this design?
2. Under what conditions would this system fail?
3. What assumptions might be wrong?
4. What edge cases weren't considered?
5. How would this perform under 10x load?
6. What would an attacker target in this system?
7. What operational nightmares might this create?

Finally, provide an improved design that addresses these concerns.

Compare three approaches for implementing [solution]:

Approach 1: [describe approach]
Approach 2: [describe approach]  
Approach 3: [describe approach]

Evaluation Matrix:
                  | Approach 1 | Approach 2 | Approach 3
Performance       |     ?      |     ?      |     ?
Scalability       |     ?      |     ?      |     ?
Complexity        |     ?      |     ?      |     ?
Cost (monthly)    |     ?      |     ?      |     ?
Time to implement |     ?      |     ?      |     ?
Maintenance       |     ?      |     ?      |     ?
Risk level        |     ?      |     ?      |     ?

For each cell, provide:
- Specific rating (1-10)
- Detailed justification
- Key considerations

Then recommend the optimal approach with reasoning.

Generate Python code meeting these exact specifications:

Function: process_customer_transaction

Input Specification:
- transaction_event: Dict with keys ['customer_id', 'amount', 'currency', 'timestamp', 'merchant_id']
- validation_rules: List[Callable] for custom validation
- processing_config: ProcessingConfig dataclass

Output Specification:
- TransactionResult dataclass with fields: [status, processed_amount, fees, risk_score, audit_trail]

Behavior Specification:
1. Validate input schema (raise ValidationError for invalid)
2. Apply all validation rules (short-circuit on first failure)
3. Calculate fees based on transaction amount and merchant tier
4. Compute risk score using ML model (boto3 call to SageMaker)
5. Log all steps to CloudWatch with correlation ID
6. Store audit trail in DynamoDB
7. Return structured result

Error Handling:
- ValidationError: Invalid input format
- ProcessingError: Business logic failures  
- ExternalServiceError: AWS service failures
- All errors must include correlation ID and detailed context

Performance Requirements:
- Complete within 2 seconds
- Handle concurrent calls (thread-safe)
- Efficient memory usage for large transactions

Security Requirements:
- Sanitize all inputs
- Encrypt sensitive data in logs
- Validate all external service responses

Include:
- Complete implementation with all imports
- Comprehensive docstring with examples
- Type hints for all parameters and returns
- Error handling for every failure mode
- Unit tests covering all paths

Step 1: Create the basic data model
Generate Pydantic models for the transaction processing system with full validation.

Step 2: Add the core business logic
Implement the transaction processing function with all business rules.

Step 3: Add AWS integrations
Integrate with DynamoDB, SageMaker, and CloudWatch with proper error handling.

Step 4: Add advanced features
Implement retry logic, circuit breakers, and performance optimizations.

Step 5: Add comprehensive testing
Generate unit tests, integration tests, and performance tests.

Complete each step fully before moving to the next. Ask me to proceed when ready.

Generate production-ready code (not prototype) with:

✅ Comprehensive error handling for all failure modes
✅ Structured logging with correlation IDs
✅ Metrics and observability instrumentation  
✅ Input validation and sanitization
✅ Type hints and docstrings
✅ Configuration management (environment variables)
✅ Retry logic with exponential backoff
✅ Circuit breaker patterns for external services
✅ Resource cleanup (context managers)
✅ Security best practices (secrets management)
✅ Performance optimizations
✅ Memory and resource efficiency
✅ Graceful degradation patterns
✅ Health check endpoints
✅ API documentation
✅ Unit tests with >90% coverage

Don't provide placeholder comments like "# Add error handling here"
Implement everything fully and comprehensively.

Context Injection - AWS Lambda Best Practices:

You have deep knowledge of these Lambda optimization patterns:
- Connection pooling for RDS/external APIs
- Provisioned concurrency for predictable cold starts
- Memory optimization (CPU scales with memory)
- /tmp directory usage for temporary files
- Environment variable vs Parameter Store usage
- VPC configuration impact on cold starts
- Dead letter queue configuration
- X-Ray tracing integration patterns
- CloudWatch custom metrics
- Lambda layers for shared dependencies

Apply this knowledge when generating solutions.

Anti-Patterns to Avoid:

AWS Anti-Patterns:
❌ Creating new boto3 clients on every invocation
❌ Not using connection pooling for databases
❌ Ignoring Lambda timeout configurations
❌ Missing error handling for AWS service throttling
❌ Not implementing proper retry logic
❌ Using synchronous calls where async would work
❌ Ignoring cost implications of service choices

Python Anti-Patterns:
❌ Using bare except: clauses
❌ Not using context managers for resources
❌ Mutating default arguments
❌ Not validating external inputs
❌ Ignoring type hints
❌ Not implementing proper logging
❌ Memory leaks in long-running processes

Ensure your solution avoids all these anti-patterns and explain why.

Domain Context - High-Frequency Trading Systems:

Key Requirements:
- Latency measured in microseconds, not milliseconds
- Data integrity is non-negotiable (financial regulations)
- System must handle market data bursts (10,000+ messages/second)
- Compliance logging required for all transactions
- Fail-safe mechanisms prevent accidental trades
- Real-time risk monitoring and circuit breakers

Technical Constraints:
- Market hours: 9:30 AM - 4 PM EST (peak load)
- After-hours processing: batch operations only
- Data sources: Multiple exchanges with different formats
- Regulatory requirements: FINRA, SEC compliance
- Audit requirements: 7-year data retention

Apply this domain knowledge to all architectural decisions.

Response Format:

## Executive Summary
[2-3 sentences: What you're recommending and why]

## Technical Architecture
[Detailed system design with text diagrams]

## Implementation Plan
[Step-by-step development approach]

## Code Implementation
[Complete, production-ready code with comments]

## Testing Strategy
[Unit, integration, and load testing approaches]

## Deployment Guide
[Step-by-step deployment instructions]

## Monitoring & Observability
[Metrics, logging, and alerting configuration]

## Cost Analysis
[Estimated monthly AWS costs with breakdown]

## Risk Assessment
[Potential failure modes and mitigations]

## Follow-up Actions
[Next steps and recommendations]

Follow this exact format. Make each section comprehensive and actionable.

Depth Level: Expert Implementation Detail

For each recommendation, provide:

Level 1: What (the solution)
Level 2: Why (the reasoning and trade-offs) 
Level 3: How (specific implementation steps)
Level 4: Edge Cases (failure modes and handling)
Level 5: Optimization (performance and cost improvements)

Example depth for "Use DynamoDB for session storage":

Level 1: Store user sessions in DynamoDB with TTL
Level 2: DynamoDB provides automatic scaling, built-in TTL for cleanup, and consistent sub-10ms latency
Level 3: Create table with partition key 'session_id', enable TTL on 'expires_at' field, use boto3 for operations
Level 4: Handle throttling with exponential backoff, implement fallback for service outages, validate session data integrity
Level 5: Use on-demand billing for unpredictable traffic, implement read replicas for global applications, optimize item size

Apply this depth to all recommendations.

Session Goal: Build complete fraud detection system

Turn 1: Architecture Design
"Design the high-level architecture for a real-time fraud detection system processing 10,000 transactions/second. Focus on data flow, service selection, and scalability patterns."

Turn 2: Component Deep-Dive  
"Now detail the ML inference pipeline component. Include model serving, feature engineering, and real-time scoring with sub-100ms latency requirements."

Turn 3: Implementation
"Generate the Python implementation for the transaction scoring service. Include all AWS integrations, error handling, and monitoring."

Turn 4: Testing & Validation
"Create comprehensive tests for the scoring service. Include unit tests, integration tests, and load testing scenarios."

Turn 5: Deployment & Operations
"Provide the complete deployment automation using CDK, monitoring setup, and operational runbooks."

Iteration 1: Basic Implementation
"Create a working solution that meets core requirements"

Iteration 2: Error Handling
"Enhance with comprehensive error handling and recovery mechanisms"  

Iteration 3: Performance Optimization
"Optimize for performance, scalability, and cost efficiency"

Iteration 4: Security Hardening
"Add security controls, input validation, and compliance features"

Iteration 5: Operational Excellence
"Add monitoring, alerting, debugging capabilities, and documentation"

Each iteration should build on the previous version, not start over.

Review Round 1 - Security Expert
"Review this solution from a security perspective. Identify vulnerabilities, attack vectors, and security improvements."

Review Round 2 - Performance Expert  
"Review this solution for performance and scalability. Identify bottlenecks, optimization opportunities, and scaling challenges."

Review Round 3 - Operations Expert
"Review this solution from an operational perspective. Consider monitoring, debugging, maintenance, and incident response."

Review Round 4 - Cost Optimization Expert
"Review this solution for cost efficiency. Identify cost optimization opportunities and alternative approaches."

Synthesize all feedback into final recommendations.

Solve this optimization problem:

Requirements:
✅ Process 1M+ events per hour
✅ Sub-100ms latency for real-time queries  
✅ 99.9% availability SLA
✅ PCI DSS compliance for payment data
✅ Monthly AWS cost under $10K
✅ Zero data loss tolerance
✅ Global deployment (US, EU, APAC)
✅ Auto-scaling for traffic spikes
✅ Blue-green deployment capability

Hard Constraints:
- Cannot use services not available in all regions
- Must use managed services only (no EC2)
- Data sovereignty requirements (EU data stays in EU)
- Encryption at rest and in transit required
- Audit logging for all data access

Find a solution that satisfies ALL constraints simultaneously.

Simulate this scenario step by step:

Initial State:
- Black Friday traffic surge (10x normal load)
- Primary database region (us-east-1) experiences partial outage
- CDN cache hit rate drops to 60% due to new content
- Payment processor introduces 2-second latency
- Mobile app traffic increases 500%

Walk through:
1. How the system responds in first 30 seconds
2. What automatic failover mechanisms activate
3. Which components become bottlenecks
4. How monitoring systems alert operations team
5. What manual interventions might be needed
6. How the system recovers as issues resolve

For each step, explain:
- System behavior and metrics
- Customer impact
- Operational actions
- Recovery progress

Time-boxed solution needed:

Scenario: CEO announces new feature required for customer demo in 2 weeks. The feature needs real-time analytics dashboard showing user behavior patterns.

Week 1 Deliverables:
- Basic data pipeline collecting user events
- Simple analytics processing
- MVP dashboard with core metrics

Week 2 Deliverables:  
- Enhanced real-time processing
- Advanced visualizations
- Performance optimization
- Basic monitoring

Constraints:
- Use existing AWS infrastructure
- Leverage team's Python/React skills
- Must be demonstrable to enterprise customers
- Plan for scaling post-demo

Provide week-by-week implementation plan with realistic scope.

❌ "Create a Lambda function for data processing"

✅ "Create a Lambda function that processes real-time stock price feeds from NYSE, validates against business rules, enriches with historical volatility data, and publishes alerts for significant price movements. Handle 10,000+ price updates per second during market hours."

Requirements:
- Provide complete, runnable code
- Include all imports and dependencies
- Show actual AWS configuration
- No placeholder comments
- Include error handling for every step
- Add comprehensive docstrings and type hints

If you cannot provide full implementation, explain exactly what information you need.

Don't just tell me best practices. For each recommendation:

1. Explain the specific benefit in my context
2. Identify the trade-offs and costs
3. Compare to alternative approaches
4. Show the implementation specifics
5. Quantify the impact where possible

Example: Instead of "use caching," explain "implement Redis ElastiCache to reduce DynamoDB read costs by ~60% ($2K/month savings) at the expense of eventual consistency for user profile data, which is acceptable given our 5-second update tolerance."

This solution will be deployed to production handling:
- 10 million users
- $50M annual revenue dependency  
- 24/7/365 availability requirement
- SOC2 compliance needed
- Regulatory audit requirements

Redesign your solution considering:
- What happens under peak load?
- How do we handle partial failures?
- What are the security implications?
- How do we monitor and debug issues?
- What's the disaster recovery plan?

Let's work through this problem using the Socratic method:

Problem: [state your problem]

Question 1: What are we really trying to solve here? What's the core business problem behind the technical requirements?

Question 2: What assumptions are we making? Which of these assumptions might be wrong?

Question 3: What are the constraints we're working within? Which constraints are real vs self-imposed?

Question 4: What would happen if we approached this completely differently? What alternative solutions exist?

Question 5: What are the second and third-order effects of our solution? How might it impact other systems?

Question 6: How would we know if our solution is working? What metrics would prove success?

Answer each question thoroughly before moving to the next.

Apply first principles thinking to this challenge:

Step 1: Identify the fundamental requirements
Break down to the most basic, irreducible elements. What laws of physics, business logic, or technical constraints are we dealing with?

Step 2: Question all assumptions
List every assumption in the current approach. Challenge each one: Is this assumption actually true? Can it be changed?

Step 3: Reconstruct from fundamentals
Build the solution from basic principles without relying on existing patterns or conventional wisdom.

Step 4: Identify novel approaches
What solutions emerge that wouldn't be obvious from incremental thinking?

Work through each step systematically.

Analyze this using systems thinking:

System Boundaries: Define what's inside/outside our system
Stakeholders: Who are all the parties affected by this system?
Feedback Loops: What are the reinforcing and balancing feedback loops?
Mental Models: What assumptions do different stakeholders have?
System Structure: What are the relationships between components?
System Behavior: What patterns emerge over time?
Leverage Points: Where can small changes create big impacts?
Unintended Consequences: What could go wrong? What are the side effects?

Map out the system dynamics before proposing solutions.

Analyze this prompt and improve it for better results:

[your original prompt]

Evaluation criteria:
- Clarity and specificity  
- Context richness
- Output quality control
- Constraint specification
- Result reproducibility

Provide:
1. Analysis of current prompt weaknesses
2. Improved version with explanations
3. Additional techniques I should consider
4. Examples of even more advanced prompting for this type of request

Debug this prompting session:

My Goal: [what you wanted to achieve]
My Prompt: [your original prompt]
AI Response: [what AI actually provided]
Gap: [how the response fell short]

Analyze:
1. Was my prompt ambiguous or unclear?
2. Did I provide sufficient context?
3. Were my expectations realistic?
4. What constraints or specifications did I miss?
5. How should I restructure the prompt?

Provide a debugged version of the prompt that would achieve my goal.

Create an Architecture Decision Record for [decision]:

## Context
[Current situation and forces driving the decision]

## Decision
[The specific decision made]

## Status
[Proposed/Accepted/Deprecated]

## Consequences
[Results of the decision, both positive and negative]

## Alternatives Considered
[Other options evaluated and why they were rejected]

## Implementation Notes
[Specific details about how to implement]

## Success Metrics
[How we'll measure if this decision was correct]

## Review Date
[When to reassess this decision]

Provide detailed analysis for each section with quantitative data where possible.

Create incident response procedures for [scenario]:

## Incident Detection
- Monitoring alerts that indicate this issue
- Manual detection procedures
- Escalation thresholds

## Immediate Response (0-15 minutes)
- Emergency mitigation steps
- Communication protocols
- Initial assessment procedures

## Investigation Phase (15-60 minutes)
- Diagnostic procedures
- Data collection requirements
- Root cause analysis approach

## Resolution Phase
- Step-by-step remediation
- Rollback procedures if needed
- Verification steps

## Post-Incident
- Communication updates
- Documentation requirements
- Follow-up actions

Include specific commands, scripts, and decision trees.

I want to discover your advanced capabilities for [domain]. 

Show me:
1. The most sophisticated analysis you can perform in this domain
2. Advanced techniques I might not know about
3. Complex multi-step processes you can handle
4. Integration capabilities with external systems
5. Quality assurance and validation methods you can apply

For each capability, provide:
- A concrete example
- When it's most useful
- How to prompt for it effectively
- What inputs/context you need

Don't limit yourself to basic features - show me the advanced stuff.

Let's test your limits on this complex problem:

[Describe a complex multi-faceted problem]

Requirements:
- Consider at least 15 different variables
- Account for dependencies and interactions
- Provide quantitative analysis where possible
- Consider edge cases and failure modes
- Include implementation timeline
- Address regulatory and compliance issues
- Consider multiple stakeholder perspectives
- Provide risk assessment and mitigation
- Include cost-benefit analysis
- Design monitoring and validation approaches

Show me the most comprehensive analysis you can provide.