Software Developers AI Prompts

Generate a comprehensive README.md file for the following project:

Project details:
- Project name: [name]
- Description: [what it does in one sentence]
- Language/Framework: [tech stack]
- Type: [library/app/API/CLI tool]
- License: [MIT/Apache/GPL/other]
- Author: [name/organization]
- Repository: [GitHub URL]

README should include:

# Project Name

## Badges
[Build status, version, license badges]

## Description
Clear explanation of what the project does and why

## Features
Key features bullet list

## Demo
Screenshot or GIF if applicable

## Prerequisites
What needs to be installed first

## Installation
Step by step installation instructions

## Quick Start
Minimal code to get running in 5 minutes

## Usage
Detailed usage with examples

## Configuration
All configuration options explained

## API Reference
If applicable

## Contributing
How to contribute

## Testing
How to run tests

## Changelog
Version history

## License
License information

## Contact
How to reach maintainers

Write in clear technical English
Use proper markdown formatting throughout

Prepare comprehensive interview questions and answers for a [role] position at [company type].

Interview details:
- Role: [Frontend/Backend/Full Stack/DevOps/other]
- Level: [Junior/Mid/Senior/Staff]
- Tech stack: [list technologies]
- Interview type: [technical screen/onsite/system design]
- Company type: [startup/mid-size/FAANG]

Generate interview preparation covering:

1. TECHNICAL QUESTIONS (10 questions)
   - Core language concepts
   - Framework specific questions
   - Data structures and algorithms
   Include: question + ideal answer + follow ups

2. SYSTEM DESIGN QUESTIONS (3 questions)
   - Design a [system relevant to role]
   Include: approach framework and key points

3. BEHAVIORAL QUESTIONS (5 questions)
   - STAR format answers
   - Relevant to seniority level

4. QUESTIONS TO ASK INTERVIEWER (5 questions)
   - About team and culture
   - About technical challenges
   - About growth opportunities

5. CODING PROBLEMS (3 problems)
   - Relevant difficulty level
   - With solution approach

6. PREPARATION CHECKLIST
   - Topics to review
   - Practice resources
   - Day before checklist

Write a comprehensive pull request description for the following code change:

PR details:
- Title: [short descriptive title]
- Type: [feature/bug fix/refactor/performance/security]
- Ticket/Issue: [JIRA-123 or GitHub issue #]
- Branch: [feature/branch-name]
- Reviewers: [list]

Change details:
- What was changed: [describe]
- Why it was changed: [business reason]
- How it was implemented: [technical approach]
- Files changed: [list main files]
- Lines added/removed: [approximate]

PR description should include:
1. SUMMARY
   Clear one paragraph explanation

2. MOTIVATION AND CONTEXT
   Why was this change needed?
   What problem does it solve?

3. CHANGES MADE
   Bullet list of specific changes

4. SCREENSHOTS (if UI change)
   Before and after

5. TESTING DONE
   - Unit tests added/updated
   - Manual testing performed
   - Edge cases tested

6. BREAKING CHANGES
   Any backward incompatible changes?

7. CHECKLIST
   - Tests pass
   - Documentation updated
   - No debug code left
   - Performance impact considered

8. DEPLOYMENT NOTES
   Any special deployment steps?

Help debug the following issue in [language/framework]:

Issue details:
- Error message: [paste exact error]
- Language/Framework: [language and version]
- When it occurs: [always/intermittent/specific conditions]
- Recent changes: [what changed before bug appeared]
- Environment: [local/staging/production]
- Stack trace: [paste if available]

Debugging approach:

1. UNDERSTAND THE ERROR
   - What does the error message mean?
   - What type of error is this?
   - Is this a known issue?

2. REPRODUCE THE ISSUE
   - Minimal reproduction steps
   - Isolate the problem
   - Identify conditions that trigger it

3. HYPOTHESES
   - List 3-5 possible causes
   - Most likely cause based on error

4. DEBUGGING STEPS
   - Step by step investigation plan
   - What to check first
   - Tools to use
   - Log statements to add

5. COMMON CAUSES FOR THIS ERROR
   - Known causes in [language/framework]
   - Similar issues and solutions

6. SOLUTION OPTIONS
   - Quick fix if available
   - Proper fix recommendation
   - Prevention for future

7. VERIFICATION
   - How to confirm fix works
   - Tests to add

Be specific to the technology stack mentioned

Write complete API documentation for the following endpoint:

API details:
- API name: [name]
- Base URL: [https://api.example.com/v1]
- Authentication: [API key/OAuth/JWT/none]
- Format: [REST/GraphQL]

Endpoint to document:
- Method: [GET/POST/PUT/DELETE/PATCH]
- Path: [/endpoint/path]
- Description: [what this endpoint does]
- Use case: [when to use this]

Request:
- Headers required: [list]
- Path parameters: [list with types]
- Query parameters: [list with types]
- Request body: [JSON schema]

Response:
- Success response (200/201): [JSON example]
- Error responses: [list with codes and meanings]

Documentation should include:
1. Endpoint overview
2. Authentication section
3. Request format with all parameters explained
4. Complete request example (curl and code)
5. Response format explained
6. Complete response example
7. Error codes and handling
8. Rate limiting information
9. Code examples in JavaScript and Python
10. Common use cases

Write in clear technical English
Use proper markdown formatting

Help plan a [2-week] sprint for a [web/mobile/API] development team.

Team details:
- Team size: [X developers]
- Velocity: [X story points per sprint]
- Sprint number: [X]
- Sprint goal: [describe main objective]

Backlog items to consider:
[List your user stories or paste backlog]

For each backlog item provide:
1. Story point estimate (Fibonacci: 1,2,3,5,8,13)
2. Priority ranking (P1/P2/P3)
3. Dependencies identified
4. Acceptance criteria (3-5 items)
5. Technical tasks breakdown
6. Risk or complexity flags

Sprint planning output:
1. SPRINT GOAL statement
2. COMMITTED STORIES list with points
3. TOTAL POINTS vs velocity check
4. SPRINT RISKS identified
5. DEFINITION OF DONE criteria
6. TEAM CAPACITY check
   - Account for meetings, PTO, holidays

Format as actionable sprint plan document

Write a system architecture document for [system/application name].

System details:
- Application type: [web app/mobile/API/microservices]
- Scale: [users/requests per day]
- Tech stack: [list all technologies]
- Team size: [number of developers]
- Deployment: [cloud provider/on-premise]

Architecture document sections:

1. EXECUTIVE SUMMARY
   - Purpose of the system
   - Key architectural decisions
   - Technology choices rationale

2. SYSTEM OVERVIEW
   - High level description
   - Key stakeholders
   - Scope and boundaries

3. ARCHITECTURE DIAGRAM
   - Describe components and connections
   - Data flow between components
   - External integrations

4. COMPONENT DETAILS
   For each component:
   - Purpose and responsibility
   - Technology used
   - Interfaces/APIs
   - Data it owns

5. DATA ARCHITECTURE
   - Database design overview
   - Data flow diagram
   - Data storage decisions

6. SECURITY ARCHITECTURE
   - Authentication/Authorization
   - Data encryption
   - Network security

7. SCALABILITY AND PERFORMANCE
   - Scaling strategy
   - Performance targets
   - Caching strategy

8. DEPLOYMENT ARCHITECTURE
   - Infrastructure overview
   - CI/CD pipeline
   - Monitoring and alerting

9. DECISION LOG
   - Key architectural decisions
   - Alternatives considered
   - Reasoning

Format as professional technical document

Create a comprehensive bug report for the following issue in [application/system].

Bug details:
- Title: [short descriptive title]
- Severity: [critical/high/medium/low]
- Priority: [P1/P2/P3/P4]
- Environment: [production/staging/development]
- Version: [app version]
- Reporter: [name]
- Date found: [date]

Bug report sections:

1. SUMMARY
   One sentence description of the bug

2. STEPS TO REPRODUCE
   1. [First step]
   2. [Second step]
   3. [Third step]
   Be specific — include exact clicks, inputs, URLs

3. EXPECTED BEHAVIOR
   What should happen

4. ACTUAL BEHAVIOR
   What actually happens

5. SCREENSHOTS/VIDEOS
   [Attach evidence]

6. ENVIRONMENT DETAILS
   - OS: [Windows/Mac/Linux version]
   - Browser: [Chrome/Firefox/Safari version]
   - Device: [desktop/mobile/tablet]
   - User role: [admin/user/guest]

7. LOGS/ERROR MESSAGES
   Paste relevant error messages

8. POSSIBLE CAUSE
   Developer hypothesis if known

9. WORKAROUND
   Temporary fix if available

10. IMPACT
    How many users affected?
    Business impact?

Format as professional bug tracking ticket

Write comprehensive technical documentation for [project/feature/API].

Documentation type: [API docs/README/Architecture doc/User guide]
Audience: [developers/end users/both]
Tech stack: [list technologies]

Documentation should include:

1. OVERVIEW
   - What this does in one paragraph
   - Key features list
   - When to use this

2. PREREQUISITES
   - Required software and versions
   - Required knowledge
   - Access requirements

3. INSTALLATION/SETUP
   - Step by step instructions
   - Environment configuration
   - Common setup issues

4. QUICK START
   - Minimal working example
   - Code snippet to get started in 5 minutes

5. DETAILED USAGE
   - All features with examples
   - Configuration options
   - Code examples for each feature

6. API REFERENCE (if applicable)
   - Endpoints/methods
   - Parameters
   - Request/response examples
   - Error codes

7. TROUBLESHOOTING
   - Common errors and solutions
   - Debug tips

8. CONTRIBUTING
   - How to contribute
   - Code style guide
   - PR process

9. CHANGELOG
10. LICENSE

Write in clear, concise technical English
Include code examples in proper code blocks

Create a comprehensive code review checklist for [language/framework] code.

Code details:
- Language: [Python/JavaScript/Java/other]
- Framework: [React/Django/Spring/other]
- Type of change: [feature/bug fix/refactor/performance]
- PR size: [small/medium/large]

Review checklist categories:

FUNCTIONALITY
- Does the code do what it is supposed to do?
- Are edge cases handled?
- Is error handling implemented?
- Are there any obvious bugs?

CODE QUALITY
- Is the code readable and self documenting?
- Are variable and function names clear?
- Is the code DRY (Don't Repeat Yourself)?
- Is complexity minimized?
- Are functions small and focused?

SECURITY
- Are inputs validated and sanitized?
- Is authentication/authorization correct?
- Are secrets hardcoded? (should not be)
- SQL injection prevention?
- XSS prevention?

PERFORMANCE
- Are there obvious performance issues?
- Are database queries optimized?
- Is caching used appropriately?
- Are there any memory leaks?

TESTING
- Are unit tests included?
- Is test coverage adequate?
- Do all tests pass?
- Are edge cases tested?

DOCUMENTATION
- Is code commented where needed?
- Is README updated?
- Are API docs updated?

Format as detailed checklist with pass/fail/NA options