I'm new to this codebase. Can you help me understand:
1. Overall architecture and structure
2. Main technologies and frameworks used
3. Key components and their relationships
4. Entry points and data flow

Explain how the user authentication system works in this codebase:
1. Authentication flow
2. Security measures
3. Session management
4. Integration points

Help me understand the order processing logic:
1. Order creation workflow
2. Payment processing
3. Inventory management
4. Notification system

Take me through the user registration feature:
1. Start from the UI component
2. Follow the data flow
3. Explain validation logic
4. Show database interactions

Explain the microservices architecture:
1. Service boundaries
2. Communication patterns
3. Data consistency strategies
4. Deployment structure

What design patterns are used in this codebase?
1. Identify specific patterns
2. Explain their implementation
3. Show usage examples
4. Discuss benefits and trade-offs

Analyze the coding standards used:
1. Naming conventions
2. File organization
3. Code structure patterns
4. Documentation practices

Explain how external libraries are used:
1. Main dependencies and their purposes
2. Integration patterns
3. Version management
4. Potential upgrade paths

Map out internal module dependencies:
1. Module relationships
2. Circular dependencies
3. Coupling analysis
4. Refactoring opportunities

Analyze potential performance bottlenecks:
1. Database query patterns
2. API response times
3. Memory usage patterns
4. CPU-intensive operations

Identify optimization opportunities:
1. Code efficiency improvements
2. Caching strategies
3. Database optimization
4. Asset optimization

Analyze security implementations:
1. Authentication mechanisms
2. Authorization patterns
3. Input validation
4. Data protection measures

Identify potential security vulnerabilities:
1. Common security issues
2. Dependency vulnerabilities
3. Configuration problems
4. Code-level security flaws

Assess technical debt in the codebase:
1. Code complexity metrics
2. Duplication analysis
3. Maintainability issues
4. Refactoring priorities

Evaluate adherence to best practices:
1. SOLID principles
2. Clean code principles
3. Framework conventions
4. Industry standards

Create an onboarding guide for new developers:
1. Setup instructions
2. Key concepts to understand
3. Important files and directories
4. Development workflow

Suggest a learning path for understanding this codebase:
1. Start with core concepts
2. Progress through complexity levels
3. Hands-on exercises
4. Advanced topics

I want to add a new feature. Help me understand:
1. Where to implement it
2. What existing code will be affected
3. Potential integration challenges
4. Testing requirements

Show me how similar features are implemented:
1. Existing patterns to follow
2. Code reuse opportunities
3. Consistency requirements
4. Best practices to apply

Help me investigate this bug:
1. Trace the execution path
2. Identify potential causes
3. Analyze related code
4. Suggest debugging strategies

Trace how data flows through the system:
1. Input validation
2. Processing steps
3. Data transformations
4. Output generation

Generate API documentation:
1. Endpoint descriptions
2. Request/response formats
3. Authentication requirements
4. Usage examples

Add meaningful comments to complex code:
1. Algorithm explanations
2. Business logic clarification
3. Integration notes
4. Maintenance warnings

Create an FAQ based on codebase analysis:
1. Common questions about architecture
2. Development workflow queries
3. Troubleshooting guides
4. Best practices summaries

Document architectural decisions:
1. Technology choices
2. Design pattern selections
3. Trade-off considerations
4. Future implications

Identify refactoring opportunities:
1. Code duplication elimination
2. Complexity reduction
3. Performance improvements
4. Maintainability enhancements

Plan technology migrations:
1. Current state analysis
2. Target state definition
3. Migration path planning
4. Risk assessment

Plan dependency upgrades:
1. Current version analysis
2. Breaking changes assessment
3. Upgrade path planning
4. Testing requirements

Assess security update requirements:
1. Vulnerability scanning
2. Impact analysis
3. Update prioritization
4. Testing strategies

Create learning notes:
1. Key insights and discoveries
2. Important patterns and conventions
3. Gotchas and pitfalls
4. Useful code snippets

Apply learning through:
1. Small feature implementations
2. Bug fixes
3. Code reviews
4. Refactoring exercises

Test my understanding of the codebase:
1. Quiz me on key concepts
2. Ask about implementation details
3. Challenge me with scenarios
4. Verify my mental model

Validate understanding through:
1. Code modification exercises
2. Feature implementation tasks
3. Bug fixing challenges
4. Architecture discussions