Ship Faster with
Battle-Tested Prompts

As a Senior Developer with expertise in code analysis, thoroughly review and comprehend the provided complete code base, including all relevant standards and Markdown (MD) files, from end to end. This includes understanding the structure, logic, dependencies, and any best practices involved. Once understood, maintain this knowledge in memory for the duration of this conversation thread to support upcoming tasks and feature development. Please confirm your understanding before proceeding.

WHY THIS WORKS:
1. Precise Context: Specifies exactly what to understand (structure, logic, dependencies)
2. Memory Retention: Ensures AI maintains knowledge throughout the conversation
3. Accountability: Requires confirmation before proceeding

RESULT: Your AI becomes a true coding partner, not just a tool.

Analyze my project and provide a complete development environment optimization:

1. PROJECT ANALYSIS:
   - Scan package.json/requirements.txt for dependencies
   - Identify framework and tech stack
   - Check for existing configuration files
   - Analyze folder structure and architecture patterns

2. OPTIMIZATION RECOMMENDATIONS:
   - Essential VS Code extensions for this project
   - Recommended .env variables setup
   - Optimal tsconfig/webpack/vite configuration
   - Pre-commit hooks and linting setup
   - Performance optimization settings

3. PRODUCTIVITY BOOSTERS:
   - Custom snippets for common patterns
   - Debugging configurations
   - Test running shortcuts
   - Build optimization tips

4. BEST PRACTICES CHECKLIST:
   - Security configurations
   - Code quality tools
   - Documentation standards
   - Git workflow recommendations

Provide specific, actionable steps with exact configurations I can copy-paste.

I need help debugging an issue. Please follow this systematic approach:

[DESCRIBE YOUR ISSUE HERE]

1. INITIAL DIAGNOSIS:
   - What is the expected behavior?
   - What is the actual behavior?
   - When did this start happening?
   - What changes were made recently?

2. SYSTEMATIC INVESTIGATION:
   - Check error messages and stack traces
   - Identify the exact line/component causing issues
   - Review recent commits for changes
   - Check for environment-specific issues

3. ROOT CAUSE ANALYSIS:
   - List top 3 most likely causes
   - Provide evidence for each hypothesis
   - Suggest diagnostic tests to confirm

4. SOLUTION APPROACH:
   - Step-by-step fix with code
   - Alternative solutions if first doesn't work
   - Prevention strategies for future

5. VERIFICATION:
   - Tests to confirm fix works
   - Edge cases to check
   - Performance impact assessment

Be thorough but concise. Prioritize the most likely solutions first.

Help me master [TECHNOLOGY/FRAMEWORK NAME] efficiently:

1. FOUNDATION (Day 1-3):
   - Core concepts I MUST understand
   - Top 5 most important features
   - Common misconceptions to avoid
   - Mental models for thinking about this tech

2. HANDS-ON PRACTICE (Day 4-7):
   - Build a mini-project that covers 80% of use cases
   - Step-by-step tutorial with best practices
   - Common patterns and anti-patterns
   - Performance optimization basics

3. REAL-WORLD APPLICATION (Week 2):
   - Production-ready setup and configuration
   - Integration with existing tools/frameworks
   - Testing strategies
   - Deployment considerations

4. MASTERY RESOURCES:
   - Top 3 documentation pages to bookmark
   - Best YouTube channels/courses
   - GitHub repos to study
   - Community resources and forums

5. QUICK REFERENCE:
   - Cheat sheet of most-used commands/methods
   - Debugging tips specific to this tech
   - Performance optimization checklist
   - Common errors and solutions

Focus on practical, immediately applicable knowledge. Skip the fluff.

Review this code for:
1. Obvious bugs or errors
2. Security vulnerabilities
3. Performance issues
4. Better alternatives
5. Quick wins for improvement

Be concise. Focus on critical issues only.

Refactor this code following these principles:

1. CLEAN CODE:
   - Single responsibility
   - DRY (Don't Repeat Yourself)
   - Clear naming conventions
   - Remove code smells

2. PERFORMANCE:
   - Optimize algorithms (time/space complexity)
   - Reduce unnecessary operations
   - Implement caching where beneficial

3. MAINTAINABILITY:
   - Add meaningful comments
   - Improve error handling
   - Add type safety
   - Extract magic numbers to constants

4. TESTING:
   - Make it testable
   - Suggest unit tests
   - Add edge case handling

Provide the refactored code with explanations for major changes.

Generate comprehensive documentation for this [CODE/PROJECT]:

1. README.md with:
   - Project overview
   - Installation steps
   - Usage examples
   - API documentation
   - Contributing guidelines

2. Code comments:
   - JSDoc/docstrings for functions
   - Inline comments for complex logic
   - TODO markers for improvements

3. API docs:
   - Endpoint descriptions
   - Request/response examples
   - Error codes
   - Authentication details

Make it clear, concise, and developer-friendly.