Coding & Development Prompts

Review the following code for best practices, performance, security, and maintainability:

[PASTE YOUR CODE]

Language/Framework: [e.g., Python/Django, JavaScript/React]

Provide:
1. Security vulnerabilities
2. Performance bottlenecks
3. Code smell detection
4. Best practice violations
5. Refactoring suggestions
6. Rating (1-10) with justification

Analyze this code for performance optimization opportunities:

[PASTE CODE]

Current issues: [DESCRIBE PERFORMANCE PROBLEMS]
Constraints: [e.g., Memory limit, Response time requirements]

Suggest:
- Algorithm improvements
- Data structure optimizations
- Caching strategies
- Database query optimizations
- Time/space complexity analysis

Perform a security audit on this code:

[PASTE CODE]

Application type: [e.g., Web app, API, Mobile app]

Check for:
- SQL injection vulnerabilities
- XSS vulnerabilities
- Authentication/authorization flaws
- Data exposure risks
- Input validation issues
- OWASP Top 10 violations

Provide severity ratings and remediation steps.

Refactor this code to improve readability and maintainability:

[PASTE CODE]

Goals:
- Reduce complexity
- Improve naming
- Extract reusable functions
- Follow SOLID principles
- Add type hints/annotations

Provide before/after comparison with explanations.

Recommend appropriate design patterns for:

Problem: [DESCRIBE YOUR CODING CHALLENGE]
Language: [PROGRAMMING LANGUAGE]
Current approach: [PASTE CODE OR DESCRIBE]

Suggest:
1. Best design pattern to use
2. Why it fits
3. Implementation example
4. Pros/cons
5. Alternative patterns

Generate comprehensive documentation for:

[PASTE CODE OR FUNCTION]

Include:
- Function/class description
- Parameter documentation
- Return value documentation
- Usage examples
- Edge cases and error handling
- Time/space complexity

Format: [JSDoc / Docstring / XML Comments]

Audit this code for accessibility (a11y) compliance:

[PASTE FRONTEND CODE]

Framework: [e.g., React, Vue, HTML/CSS]

Check for:
- WCAG 2.1 AA compliance
- Keyboard navigation
- Screen reader compatibility
- ARIA attributes
- Color contrast
- Focus management

Provide specific fixes with code examples.

Help me debug this issue:

Error message: [PASTE ERROR]
Code context: [PASTE RELEVANT CODE]
Language/Framework: [e.g., JavaScript/Node.js]
What I expect: [EXPECTED BEHAVIOR]
What happens: [ACTUAL BEHAVIOR]
What I've tried: [LIST ATTEMPTS]

Provide:
1. Root cause analysis
2. Step-by-step solution
3. Why it happened
4. How to prevent it

Analyze this stack trace and help me fix the issue:

[PASTE FULL STACK TRACE]

Context:
- When it happens: [DESCRIBE SCENARIO]
- Recent changes: [WHAT YOU CHANGED]
- Environment: [Dev/Staging/Production]

Provide:
1. Line-by-line stack trace explanation
2. Root cause identification
3. Fix implementation
4. Prevention strategy

Identify potential memory leaks in:

[PASTE CODE]

Language: [e.g., JavaScript, Python, Java]
Symptoms: [DESCRIBE MEMORY ISSUES]
Environment: [Runtime details]

Analyze:
- Potential leak sources
- Object retention issues
- Event listener problems
- Closure issues
- Recommended profiling approach

Help debug this concurrency issue:

[PASTE CODE]

Problem: [DESCRIBE RACE CONDITION]
Expected behavior: [WHAT SHOULD HAPPEN]
Actual behavior: [WHAT HAPPENS]

Provide:
1. Race condition identification
2. Thread-safe solution
3. Synchronization approach
4. Testing strategy

Debug this API integration issue:

API: [API NAME/ENDPOINT]
Error: [ERROR MESSAGE OR BEHAVIOR]
Request: [PASTE REQUEST CODE]
Response: [PASTE RESPONSE]
Documentation: [API DOCS URL]

Help me:
1. Identify the issue
2. Correct the request format
3. Handle edge cases
4. Add proper error handling

Optimize this slow database query:

[PASTE SQL/QUERY]

Database: [e.g., PostgreSQL, MongoDB]
Current execution time: [TIME]
Table sizes: [APPROXIMATE ROWS]
Indices: [LIST CURRENT INDICES]

Suggest:
- Query optimization
- Index recommendations
- Schema improvements
- Alternative approaches

Generate production-ready boilerplate for:

Project type: [REST API / GraphQL / Microservice / Web App]
Language/Framework: [e.g., Node.js/Express, Python/FastAPI]
Database: [PostgreSQL / MongoDB / Redis]
Key features:
- [FEATURE 1]
- [FEATURE 2]
- [FEATURE 3]

Include:
✓ Project structure
✓ Configuration files
✓ Error handling
✓ Logging
✓ Environment variables
✓ README

Generate complete CRUD operations for:

Entity: [e.g., User, Product, Order]
Framework: [e.g., Django, Express, Spring Boot]
Database: [SQL/NoSQL]

Fields:
- [FIELD 1: TYPE]
- [FIELD 2: TYPE]
- [FIELD 3: TYPE]

Include:
- Model/Schema definition
- Create, Read, Update, Delete operations
- Validation logic
- Error handling
- API endpoints (if applicable)

Create a RESTful API endpoint for:

Resource: [e.g., users, products]
Operation: [GET / POST / PUT / DELETE]
Framework: [e.g., Express, FastAPI, Flask]

Requirements:
- Authentication: [Yes/No - Method]
- Input validation
- Error responses
- Success responses
- Rate limiting
- Pagination (for lists)

Provide: Route definition, controller, and tests.

Design a database schema for:

Application: [DESCRIBE APP]
Database type: [SQL / NoSQL]
Key entities: [LIST ENTITIES]

Generate:
1. Entity-Relationship diagram (text)
2. Table/collection definitions
3. Relationships (foreign keys, references)
4. Indexes for performance
5. Sample migration script
6. Normalization notes

Generate a React component for:

Component purpose: [DESCRIBE FUNCTIONALITY]
Props needed: [LIST PROPS WITH TYPES]
State management: [useState / useContext / Redux]
Styling: [Tailwind / CSS Modules / Styled Components]

Include:
- TypeScript types
- PropTypes validation
- Error boundaries
- Loading states
- Accessibility attributes
- Storybook story (optional)

Create a command-line tool for:

Purpose: [WHAT IT DOES]
Language: [Python / Node.js / Go / Rust]
Commands:
- [COMMAND 1]: [DESCRIPTION]
- [COMMAND 2]: [DESCRIPTION]

Include:
- Argument parsing
- Help text
- Error handling
- Progress indicators
- Configuration file support
- Installation instructions

Implement the following algorithm:

Algorithm: [NAME OR DESCRIPTION]
Language: [PROGRAMMING LANGUAGE]
Input: [DESCRIBE INPUT FORMAT]
Output: [DESIRED OUTPUT]
Constraints: [TIME/SPACE COMPLEXITY REQUIREMENTS]

Provide:
1. Clean implementation
2. Time complexity analysis
3. Space complexity analysis
4. Test cases
5. Edge case handling

Create a regex pattern to:

Task: [WHAT TO MATCH/VALIDATE]
Examples of valid input:
- [EXAMPLE 1]
- [EXAMPLE 2]
Examples of invalid input:
- [EXAMPLE 1]
- [EXAMPLE 2]

Provide:
1. Regex pattern
2. Explanation of each part
3. Test cases
4. Language-specific implementation
5. Common gotchas

Generate comprehensive unit tests for:

[PASTE FUNCTION/CLASS]

Framework: [Jest / pytest / JUnit / PHPUnit]
Test coverage goal: [e.g., 90%]

Include tests for:
- Happy path scenarios
- Edge cases
- Error conditions
- Boundary values
- Mock external dependencies
- Setup and teardown

Provide: Test file with descriptive test names.

Create integration tests for:

Feature: [DESCRIBE FEATURE]
Components involved: [LIST COMPONENTS/SERVICES]
Test framework: [e.g., Cypress, Selenium, Supertest]

Test scenarios:
- [SCENARIO 1]
- [SCENARIO 2]
- [SCENARIO 3]

Include:
- Test setup
- API mocking
- Database seeding
- Assertions
- Cleanup

Generate realistic test data for:

Entity: [e.g., User, Product, Transaction]
Quantity: [NUMBER OF RECORDS]
Data format: [JSON / SQL / CSV]

Fields:
- [FIELD 1: TYPE and constraints]
- [FIELD 2: TYPE and constraints]
- [FIELD 3: TYPE and constraints]

Requirements:
- Realistic values
- Edge cases included
- Referential integrity
- Randomization seed (for reproducibility)

Create end-to-end test scenarios for:

User flow: [DESCRIBE USER JOURNEY]
Application: [WEB / MOBILE / DESKTOP]
Test tool: [Playwright / Cypress / Selenium]

Scenarios to cover:
1. Happy path
2. Authentication edge cases
3. Error handling
4. Edge cases
5. Performance checks

Provide: Test script with assertions and wait strategies.

Create mocks and stubs for testing:

External dependency: [API / Database / Service]
Framework: [Sinon / Jest / unittest.mock]

Mock these interactions:
- [INTERACTION 1]
- [INTERACTION 2]
- [INTERACTION 3]

Include:
- Mock setup code
- Different response scenarios
- Error simulation
- Spy/assertion examples

Analyze test coverage gaps in:

[PASTE CODE TO BE TESTED]

Current tests: [PASTE OR DESCRIBE EXISTING TESTS]

Identify:
1. Untested code paths
2. Missing edge cases
3. Critical scenarios not covered
4. Recommended new tests
5. Priority order for implementation

Generate API documentation for:

[PASTE API CODE OR ENDPOINTS]

Format: [OpenAPI / Swagger / Markdown]

Include for each endpoint:
- Description
- HTTP method & path
- Request parameters
- Request body schema
- Response schema
- Status codes
- Error responses
- Code examples (curl, Python, JavaScript)

Create a comprehensive README for:

Project: [PROJECT NAME]
Description: [WHAT IT DOES]
Tech stack: [LANGUAGES/FRAMEWORKS]
Key features: [LIST FEATURES]

Include:
📋 Project description
✨ Features
🚀 Quick start
📦 Installation
⚙️ Configuration
💻 Usage examples
🧪 Running tests
📝 Contributing
📄 License

Tone: Professional yet approachable

Add comprehensive inline comments to:

[PASTE CODE]

Comment style: [Language-specific conventions]

Add comments for:
- Complex logic explanation
- Function/class purposes
- Parameter descriptions
- Return values
- Edge cases handled
- TODO/FIXME notes
- Algorithm explanations

Keep comments concise but informative.

Write a technical specification for:

Feature: [FEATURE NAME]
Purpose: [WHY IT'S NEEDED]
Stakeholders: [WHO REQUESTED IT]

Document:
1. Requirements (functional & non-functional)
2. Technical approach
3. Architecture diagram (text-based)
4. Data models
5. API contracts
6. Security considerations
7. Performance requirements
8. Testing strategy
9. Deployment plan
10. Success metrics

Explain this code in the simplest terms possible:

[PASTE CODE]

Audience: [Beginner / Non-technical stakeholder]

Explain:
1. What it does (high-level, no jargon)
2. Why it's structured this way
3. Real-world analogy
4. Key concepts used (explained simply)

Use everyday language and analogies.

Explain this programming concept:

Concept: [e.g., Closures, Promises, Recursion]
Language: [PROGRAMMING LANGUAGE]
My level: [Beginner / Intermediate / Advanced]

Provide:
1. Simple definition
2. Why it matters
3. Code example (simple)
4. Code example (advanced)
5. Common pitfalls
6. When to use it
7. Related concepts

Provide a detailed walkthrough of:

[PASTE CODE]

Walk me through:
1. Execution flow (step-by-step)
2. What each section does
3. Variable state changes
4. Function calls and returns
5. Edge cases handled
6. Performance considerations

Explain as if pair programming.

Compare these technologies for my use case:

Options:
1. [TECHNOLOGY 1]
2. [TECHNOLOGY 2]
3. [TECHNOLOGY 3]

My use case: [DESCRIBE PROJECT]
Team size: [NUMBER]
Experience: [SKILL LEVELS]
Constraints: [TIME/BUDGET/REQUIREMENTS]

Compare:
- Learning curve
- Performance
- Community support
- Ecosystem
- Cost
- Scalability

Recommendation with justification.

Create a beginner tutorial for:

Framework: [e.g., React, Vue, Django]
Project: [SIMPLE PROJECT IDEA]
Target audience: [EXPERIENCE LEVEL]

Structure:
1. Introduction & setup
2. Core concepts (3-5)
3. Step-by-step implementation
4. Common issues & solutions
5. Next steps for learning
6. Resources

Keep it beginner-friendly with explanations.

Explain this code pattern I encountered:

[PASTE CODE PATTERN]

Context: [WHERE YOU FOUND IT]

Explain:
1. What pattern this is
2. Why it's used
3. Benefits of this approach
4. When to use vs avoid
5. Simpler alternatives
6. Common variations

Relate to concepts I might already know.

Teach me a debugging strategy for:

Problem type: [e.g., Performance issue, Logic bug, Integration failure]
Complexity: [Simple / Moderate / Complex]

Teach me:
1. How to approach this type of issue
2. What to check first (debugging checklist)
3. Tools to use
4. Common causes
5. Prevention strategies
6. Example scenario walkthrough

Help me build debugging skills, not just fix one issue.

Design a microservices architecture for:

Application: [DESCRIBE APP]
Expected scale: [USERS/REQUESTS]
Key features: [LIST FEATURES]

Provide:
1. Service boundaries and responsibilities
2. Communication patterns (REST/gRPC/Events)
3. Data management strategy
4. Service discovery approach
5. Deployment architecture
6. Monitoring & logging
7. Trade-offs and considerations

Guide me to profile and optimize:

Application type: [Web app / API / Data pipeline]
Language: [PROGRAMMING LANGUAGE]
Performance issue: [DESCRIBE SYMPTOMS]
Current metrics: [RESPONSE TIME / THROUGHPUT]

Provide:
1. Profiling tools to use
2. What to measure
3. How to interpret results
4. Common bottlenecks for this type
5. Optimization priorities
6. Before/after validation approach

Assess scalability of this architecture:

[PASTE ARCHITECTURE DESCRIPTION OR DIAGRAM]

Current scale: [USERS/DATA/REQUESTS]
Target scale: [FUTURE REQUIREMENTS]

Analyze:
1. Current bottlenecks
2. Single points of failure
3. Database scaling strategy
4. Caching opportunities
5. Load balancing approach
6. Cost projections
7. Migration path

Create a migration strategy for:

From: [CURRENT TECH STACK]
To: [TARGET TECH STACK]
Codebase size: [LOC / COMPLEXITY]
Team size: [NUMBER]
Timeline: [CONSTRAINT]

Provide:
1. Migration phases
2. Risk assessment
3. Parallel run strategy
4. Data migration approach
5. Testing strategy
6. Rollback plan
7. Team training needs

Design a CI/CD pipeline for:

Project: [TYPE AND TECH STACK]
Platform: [GitHub Actions / GitLab CI / Jenkins]
Environments: [Dev / Staging / Production]

Pipeline should:
- Run tests (unit, integration, e2e)
- Check code quality (linting, formatting)
- Build artifacts
- Deploy to environments
- Run security scans
- Notify team

Provide: Pipeline configuration file with comments.

Plan upgrade strategy for:

Dependency: [PACKAGE NAME]
Current version: [VERSION]
Target version: [VERSION]
Breaking changes: [LIST IF KNOWN]

Provide:
1. Impact assessment
2. Code changes needed
3. Testing checklist
4. Gradual rollout plan
5. Rollback strategy
6. Team communication plan

Design a system for:

Problem: [e.g., Design Twitter, Design URL shortener]
Scale: [EXPECTED USERS/REQUESTS]
Constraints: [ANY SPECIFIC REQUIREMENTS]

Provide:
1. Requirements clarification
2. High-level architecture
3. Component details
4. Data model
5. API design
6. Scalability considerations
7. Trade-offs discussed
8. Bottleneck identification

Format as interview response.