Every Developer Should Know These 15 Complex ChatGPT Prompts

I'm preparing for technical interviews at top-tier tech companies (FAANG). 
Create a personalized preparation plan and coaching session based on my background:

CANDIDATE PROFILE:
- Experience level: [Junior/Mid/Senior]
- Technical background: [Your primary languages, frameworks, specializations]
- Target roles: [Software Engineer/ML Engineer/Data Scientist/etc.]
- Target companies: [Specific companies you're targeting]
- Interview timeline: [When your interviews are scheduled]
- Current preparation status: [What you've done so far]
- Strengths: [Your technical/interview strengths]
- Weaknesses: [Areas where you need improvement]

PREPARATION NEEDS:
1. Create a systematic study plan for the next [X weeks] with specific daily/weekly goals
2. Provide a comprehensive list of must-know algorithms and data structures with difficulty ranking
3. Generate 3 company-specific coding questions that reflect their actual interview style
4. Develop a framework for approaching system design questions relevant to my target level
5. Create behavioral interview scenarios based on my background and target companies' values
6. Suggest strategies for handling pressure and difficult questions
7. Identify company-specific cultural aspects I should emphasize in my responses

For the coding problems, please provide:
- A detailed problem statement
- Expected input/output examples
- Hints for approaching the solution
- A complete solution with time/space complexity analysis
- Common pitfalls and edge cases to consider
- Follow-up questions an interviewer might ask

Please begin by evaluating my profile and creating a tailored preparation 
strategy, then proceed with the specific interview preparation components.

I'll evaluate your solution based on these specific criteria:
1. Performance: Does it scale efficiently with large data sets?
2. Maintainability: Is the code well-structured and documented?
3. Error handling: Does it gracefully handle edge cases?
4. Security: Are there any potential vulnerabilities?
5. Test coverage: Can this solution be thoroughly tested?

For any areas that don't meet expectations, 
I'll provide specific feedback for improvement.

Initial task: [YOUR DEVELOPMENT TASK]

Thank you for this solution. Here's my feedback:
- Performance: The O(n²) approach won't scale well with large datasets
- Error handling: Missing validation for [SPECIFIC CASE]
- Maintainability: The function is doing too many things

Please refine your solution to address these specific concerns.

I'm designing a RESTful API for a [SPECIFIC DOMAIN] system. 
Let's develop this progressively:

STAGE 1: Core resource definition
- Define the essential resources and their relationships
- Specify primary attributes for each resource
- Outline basic CRUD operations

STAGE 2: Interaction patterns
- Define specialized endpoints beyond CRUD
- Specify query parameters and filtering capabilities
- Design pagination and sorting approaches

STAGE 3: Advanced considerations
- Authentication and authorization patterns
- Rate limiting and quota strategies
- Caching directives and ETag implementation
- Versioning approach
- Error handling standardization

STAGE 4: Documentation and examples
- Generate OpenAPI specifications
- Provide example requests/responses for common operations
- Document best practices for API consumers

Let's start with Stage 1: [YOUR SPECIFIC API DOMAIN DETAILS]

I need assistance with a complex Git workflow scenario:

CURRENT STATE:
- Working on feature branch 'feature/payment-processing'
- Main branch has progressed with 15+ commits since branch creation
- My branch has 7 commits, but commits 2-4 should be squashed
- There's a conflicting file: 'src/services/payment.js'
- I need to retain specific changes in lines 120-140 during merge

DESIRED OUTCOME:
- Clean history with a single logical commit for the payment feature
- Properly resolved conflicts favoring my implementation of the payment processor
- Successfully merged into the updated main branch

Please provide the step-by-step Git commands to achieve this, explaining each step and its purpose.

I'm debugging an issue with the following characteristics:

SYMPTOMS:
- [Describe the observable problem in detail]
- Occurs approximately [FREQUENCY] under [SPECIFIC CONDITIONS]
- Started after [RELEVENT CHANGE OR TIMELINE]

ENVIRONMENT:
- [Relevant technologies, versions, platforms]
- [Configuration details that might be relevant]

INVESTIGATION SO FAR:
- [Steps already taken]
- [Evidence collected]
- [Theories explored and ruled out]

ERROR LOGS:
[Include relevant logs here]

RELEVANT CODE:
[Include suspicious code sections]

Help me by:
1. Suggesting the most likely root causes based on this information
2. Proposing specific diagnostic steps to confirm each hypothesis
3. Recommending targeted fixes once the cause is identified

— A different method

• The Debugging Trick of the Rubber Duck
• This method can also be used when you're stuck on an issue.

I'm debugging an issue where [SYMPTOM]. I've tried:
- [approach 1]
- [approach 2]
- [approach 3]

I suspect the problem might be [YOUR HYPOTHESIS].

Ask me 5 targeted questions that would help identify the root cause.

I need to evaluate architectural approaches for [SPECIFIC SYSTEM COMPONENT].

For each of the following options, provide a comprehensive analysis:

OPTION 1: [Architectural approach A]
OPTION 2: [Architectural approach B]
OPTION 3: [Architectural approach C]

For each option, analyze:
1. Performance characteristics under our expected load of [SPECIFIC METRICS]
2. Development complexity and timeline implications
3. Operational considerations (monitoring, debugging, deployment)
4. Scalability limitations and growth potential
5. Security implications
6. Cost factors (development, infrastructure, maintenance)

Conclude with a recommendation based on our priority of [SPECIFIC PRIORITIES].

Generate comprehensive developer documentation for this [FUNCTION/COMPONENT/MODULE]:

[YOUR CODE]

Structure the documentation as follows:

1. OVERVIEW
   - Purpose and primary functionality
   - When to use this component vs. alternatives
   - Architectural context (where it fits in the larger system)

2. TECHNICAL SPECIFICATION
   - API reference with all methods/properties
   - Parameters, return values, and types
   - State management (if applicable)
   - Events emitted/listened for

3. IMPLEMENTATION EXAMPLES
   - Basic usage example
   - Advanced configuration example
   - Customization scenarios
   - Common patterns and best practices

4. TROUBLESHOOTING
   - Common errors and their solutions
   - Debugging strategies
   - Performance considerations

5. RELATED COMPONENTS
   - Dependencies
   - Components commonly used alongside this one
   - Alternative approaches

Format using markdown with proper headings, code blocks, tables, and emphasis where appropriate.

I need to create a comprehensive test suite for this function:

[FUNCTION CODE]

Please generate tests organized into these categories:

1. FUNCTIONAL CORRECTNESS
   - Happy path tests with various valid inputs
   - Edge case handling (empty inputs, boundary values, etc.)
   - Expected error conditions and error handling

2. PERFORMANCE CHARACTERISTICS
   - Tests verifying performance under expected loads
   - Tests for memory usage patterns
   - Time complexity verification for key operations

3. INTEGRATION POINTS
   - Tests for interactions with external dependencies
   - Mocking strategies for isolating the function
   - Testing side effects on the system

4. SECURITY CONSIDERATIONS
   - Input validation and sanitization tests
   - Authorization bypass attempts
   - Potential injection vectors

Use [Jest/Mocha/YOUR TESTING FRAMEWORK] syntax and follow AAA (Arrange-Act-Assert) pattern. 
Include setup and teardown where appropriate.

— ANOTHER METHOD Unit Test Creation Avoid creating boilerplate tests

Generate comprehensive unit tests for this function:
[FUNCTION CODE]

Test requirements:
- Use [testing framework]
- Cover edge cases including [specific scenarios]
- Achieve at least 90% code coverage
- Follow AAA (Arrange-Act-Assert) pattern

Please review this code from three different perspectives:

1. As a security specialist: 
Identify potential vulnerabilities, injection risks, or authentication issues

2. As a performance engineer: 
Highlight inefficient patterns, memory leaks, or bottlenecks

3. As a maintainability expert: 
Point out unclear naming, complex logic, or architectural concerns

CODE:
[YOUR CODE HERE]

For each role, provide specific feedback and suggested improvements.

I'm evaluating [LIBRARY/FRAMEWORK] for use in our [SPECIFIC USE CASE]. 
Provide a comprehensive analysis including:

FUNCTIONALITY ASSESSMENT
- Feature completeness for our requirements: [LIST KEY REQUIREMENTS]
- API design quality and developer experience
- Customization and extension capabilities

TECHNICAL EVALUATION
- Performance benchmarks and optimization opportunities
- Bundle size and loading impact
- Browser/environment compatibility
- TypeScript/type definition quality

COMMUNITY AND SUPPORT
- Maintenance activity (commits, issue response time)
- Community size and engagement
- Documentation quality and examples
- Commercial support options

INTEGRATION ASSESSMENT
- Compatibility with our existing stack: [list technologies]
- Migration path from our current solution
- Lock-in concerns and exit strategies

ALTERNATIVES COMPARISON
- How it compares to [alternative A], [alternative B] in key areas
- Unique advantages and disadvantages

Based on this analysis, provide a recommendation with specific justification.

I need to migrate this [SOURCE LANGUAGE/FRAMEWORK] code to [TARGET LANGUAGE/FRAMEWORK]:

SOURCE CODE:
[Your legacy code here]

MIGRATION REQUIREMENTS:
- Maintain identical business logic and behavior
- Follow [target language/framework] best practices and idioms
- Optimize for readability and maintainability
- Leverage modern features of [target language/framework]
- Ensure proper error handling equivalent to the original

SPECIFIC CONSIDERATIONS:
- The authentication mechanism needs to be adapted to use [new auth approach]
- Data types should be properly mapped (especially [specific data types])
- [Any other special considerations]

Provide me:
1. The fully migrated code implementation
2. A summary of key changes and adaptation decisions
3. Any notes on potential issues or differences in behavior
4. Recommendations for testing the migrated code

Let's establish our ongoing context for this development session:

PROJECT CONTEXT:
- We're building a GraphQL API for a healthcare scheduling system
- Tech stack: Node.js, TypeScript, Apollo Server, Prisma, PostgreSQL
- Authentication using JWT with role-based access control
- HIPAA compliance requirements in effect

CURRENT TASK:
- Implementing appointment scheduling mutation with conflict detection
- Must handle timezone conversions properly
- Should validate against provider availability rules

I'll share code snippets throughout our conversation. 
Maintain awareness of this context for all your responses.

First question: [Your specific question]

Generate a GraphQL query to:
- Fetch all users who signed up in the last 6 months
- Include their last 3 orders and shipping addresses
- Sort by most recent signup

I want to establish an AI-assisted workflow for [SPECIFIC DEVELOPMENT TASK].

Please design a comprehensive workflow that:

1. BREAKS DOWN THE TASK
   - Identify distinct components and their relationships
   - Suggest a logical development sequence
   - Define clear milestones and deliverables

2. DEFINES PROMPT TEMPLATES
   - For initial code generation
   - For code review and improvement
   - For documentation generation
   - For test case development

3. ESTABLISHES QUALITY GATES
   - Criteria for evaluating generated code
   - Feedback loops for iterative improvement
   - Integration with existing quality processes

4. PROVIDES CONTEXTUAL FRAMEWORKS
   - Project-specific knowledge to include in prompts
   - Standards and conventions to enforce
   - Reference examples to guide AI outputs

The workflow should be reusable for similar tasks and optimize for both
efficiency and quality.