Code generation:

1. Generate a boilerplate [language] code for a [class/module/component] named [name]

with the following functionality: [functionality description].
2. Create a [language] function to perform [operation] on [data structure] with the following
inputs: [input variables] and expected output: [output description].
3. Generate a [language] class for a [domain] application that includes methods for
[methods list] and properties [properties list].
4. Based on the [design pattern], create a code snippet in [language] that demonstrates its
implementation for a [use case].
5. Write a [language] script to perform [task] using [library/framework] with the following
requirements: [requirements list].

Code completion:
1. In [language], complete the following code snippet that initializes a [data structure] with
[values]: [code snippet] .
2. Finish the [language] function that calculates [desired output] given the following input
parameters: [function signature] .
3. Complete the [language] code to make an API call to [API endpoint] with [parameters]
and process the response: [code snippet] .
4. Fill in the missing [language] code to implement error handling for the following
function: [code snippet] .
5. Complete the following [language] loop that iterates over [data structure] and performs
[operation]: [code snippet] .

Bug detection:
1. Identify any potential bugs in the following [language] code snippet: [code snippet] .
2. Analyze the given [language] code and suggest improvements to prevent [error type]:
[code snippet] .
3. Find any memory leaks in the following [language] code and suggest fixes: [code snippet] .
4. Check for any race conditions or concurrency issues in the given [language] code: [code
snippet] .
5. Review the following [language] code for any security vulnerabilities: [code snippet] .
Code review:
1. Review the following [language] code for best practices and suggest improvements:
[code snippet] .
2. Analyze the given [language] code for adherence to [coding style guidelines]: [code
snippet] .

3. Check the following [language] code for proper error handling and suggest
enhancements: [code snippet] .
4. Evaluate the modularity and maintainability of the given [language] code: [code snippet] .
5. Assess the performance of the following [language] code and provide optimization
suggestions: [code snippet] .

Natural language processing:

1. Perform sentiment analysis on the following text: [text sample].
2. Extract named entities from the following text: [text sample].
3. Summarize the following article/document: [URL or text sample].
4. Identify the main topic(s) of the following text: [text sample].
5. Perform keyword extraction on the following text: [text sample].

API documentation generation:

1. Generate API documentation for the following [language] code: [code snippet] .
2. Create a concise API reference for the given [language] class: [code snippet] .
3. Generate usage examples for the following [language] API: [code snippet] .
4. Document the expected input and output for the given [language] function: [code snippet] .
5. Produce a quick-start guide for using the following [language] library: [code snippet] .

Query optimization:
1. Optimize the following SQL query for better performance: [SQL query] .
2. Analyze the given SQL query for any potential bottlenecks: [SQL query] .
3. Suggest indexing strategies for the following SQL query: [SQL query] .
4. Rewrite the following SQL query to use JOINs instead of subqueries for improved
performance: [SQL query] .
5. Optimize the following NoSQL query for better performance and resource usage:
[NoSQL query] .
 6. Identify any inefficiencies in the given database schema that may be affecting query
performance: [schema description] .
7. Suggest partitioning or sharding strategies for the following large-scale database query:
[SQL or NoSQL query] .

8. Compare the performance of the given SQL query using different database engines (e.g.,
MySQL, PostgreSQL, Oracle): [SQL query] .

Chatbots and conversational AI:

1. Create a conversational flow for a customer support chatbot that handles [issue or inquiry
type].
2. Design a chatbot interaction that helps users find [product or service] based on their
preferences and requirements.
3. Develop a conversational script for a chatbot that guides users through the [onboarding
process or feature setup].
4. Implement a chatbot that can answer frequently asked questions about [topic or domain].
5. Create a natural language interface for a chatbot that allows users to perform [specific
task or operation] using voice commands or text input.

User interface design:

1. Generate a UI mockup for a [web/mobile] application that focuses on [user goal or task].
2. Suggest improvements to the existing user interface of [app or website] to enhance
[usability, accessibility, or aesthetics].
3. Design a responsive user interface for a [web/mobile] app that adapts to different screen
sizes and orientations.
4. Create a wireframe for a [web/mobile] app that streamlines user workflows for [specific
use case].
5. Design a UI component library for a [web/mobile] app that adheres to [design system or
style guide].

Automated testing:
1. Generate test cases for the following [language] function based on the input parameters
and expected output: [function signature] .
2. Create a test script for the given [language] code that covers [unit/integration/system]
testing: [code snippet] .
 3. Generate test data for the following [language] function that tests various edge cases:
[function signature] .

4. Design a testing strategy for a [web/mobile] app that includes [unit, integration, system,
and/or performance] testing.
5. Write a test suite for a [language] API that verifies its functionality and performance
under different conditions.

Code refactoring:
1. Suggest refactoring improvements for the following [language] code to enhance
readability and maintainability: [code snippet] .
2. Identify opportunities to apply [design pattern] in the given [language] code: [code
snippet] .
3. Optimize the following [language] code for better performance: [code snippet] .
4. Refactor the given [language] code to improve its modularity and reusability: [code
snippet] .

5. Propose changes to the given [language] code to adhere to [coding style or best
practices]: [code snippet] .

Algorithm development:
1. Suggest an optimal algorithm to solve the following problem: [problem description].
2. Improve the efficiency of the given algorithm for [specific use case]: [algorithm or
pseudocode] .

3. Design an algorithm that can handle [large-scale data or high-throughput] for [specific
task or operation].
4. Propose a parallel or distributed version of the following algorithm to improve
performance: [algorithm or pseudocode] .
5. Evaluate the time and space complexity of the given algorithm and suggest optimizations:
[algorithm or pseudocode] .

Code translation:
1. Translate the following [source language] code to [target language]: [code snippet] .
2. Convert the given [source language] class or module to [target language] while
preserving its functionality and structure: [code snippet] .
 3. Migrate the following [source language] code that uses [library or framework] to [target
language] with a similar library or framework: [code snippet] .
4. Rewrite the given [source language] algorithm in [target language] with equivalent
performance characteristics: [algorithm or pseudocode] .
5. Adapt the following [source language] code snippet to [target language] while adhering
to [target language's best practices]: [code snippet] .
6. Translate the given [source language] function that handles [specific task or operation] to
[target language]: [code snippet] .

Personalized learning:
1. Curate a list of resources to learn [programming language or technology] based on my
current skill level: [beginner/intermediate/advanced].
2. Recommend a learning path to become proficient in [specific programming domain or
technology] considering my background in [existing skills or experience].
3. Suggest project ideas or coding exercises to practice and improve my skills in
[programming language or technology].
4. Recommend online courses, tutorials, or books that focus on [specific topic or concept] in
[programming language or technology].
5. Identify areas of improvement in my coding skills based on the following [language]
code: [code snippet] .

Technical writing:
1. Write a tutorial on how to implement [specific feature or functionality] using
[programming language or technology].
2. Create a step-by-step guide on setting up and configuring [tool or software] for [specific
use case or environment].
3. Draft a README file for a [programming language or technology] project that includes
an overview, installation instructions, and usage examples.
4. Write a clear and concise explanation of the [algorithm or concept] in [programming
language or technology].
5. Create a troubleshooting guide for common issues and their solutions when working with
[programming language, library, or framework].

Requirement analysis:
 1. Interpret the following project requirements and suggest a high-level architecture or
design: [requirements description] .
2. Identify potential risks or challenges in implementing the given project requirements:
[requirements description] .

3. Suggest a prioritization strategy for the following list of project requirements:

[requirements list] .

4. Based on the given project requirements, recommend a suitable [programming language,

framework, or technology]: [requirements description] .
5. Estimate the development effort and resources needed to implement the following project
requirements: [requirements description] .

Project planning:
1. Estimate the timeline and milestones for a project with the following requirements:
[requirements description] .

2. Propose a development methodology (e.g., Agile, Scrum, Waterfall) for a project with the
following characteristics: [project description] .
3. Suggest a team structure and roles for a project with the following scope and
requirements: [project description] .
4. Identify dependencies and potential bottlenecks in a project with the following
requirements and constraints: [requirements description] .
5. Develop a high-level project plan that includes tasks, resources, and timelines for a
project with the following objectives: [project objectives] .

Issue tracking and resolution:

1. Automatically categorize and prioritize the following list of reported issues: [issue list] .
2. Suggest potential solutions for the following reported issue: [issue description] .
3. Identify the root cause of the given issue and propose steps to prevent its recurrence:
[issue description] .
4. Estimate the effort required to resolve the following issue and its impact on the project
timeline: [issue description] .
5. Propose a workaround or temporary fix for the following critical issue while a permanent
solution is being developed: [issue description] .

Code visualization:
 1. Generate a UML diagram for the following [language] code: [code snippet] .
2. Create a flowchart or visual representation of the given [language] algorithm: [algorithm
or pseudocode] .
3. Visualize the call graph or dependencies of the following [language] code: [code snippet] .
4. Generate a data flow diagram for the given [language] code that demonstrates how data is
processed: [code snippet] .
5. Create an interactive visualization of the runtime behavior or performance of the
following [language] code: [code snippet] .

Data visualization:
1. Generate a bar chart that represents the following data: [data or dataset description] .
2. Create a line chart that visualizes the trend in the following time series data: [data or
dataset description] .

3. Design a heatmap that represents the correlation between the following variables:
[variable list] .
4. Visualize the distribution of the following dataset using a histogram or box plot: [data or
dataset description] .

5. Generate a scatter plot that demonstrates the relationship between the following two
variables: [variable 1] and [variable 2] .

Prototyping:
1. Generate a proof-of-concept [language] code for a [project idea or feature] based on the
following requirements: [requirements description] .
2. Create a functional prototype of a [web/mobile] app that demonstrates [specific
functionality or user flow].
3. Develop a minimal viable product (MVP) for a [product or service] based on the
following specifications: [specifications description] .
4. Implement a simple simulation or model of a [system or process] using [language or
technology].
5. Create a working demo of a [tool or feature] that showcases its potential benefits and use
cases.

Collaborative coding:
 1. Facilitate a code review session between [team member 1] and [team member 2] for the
following [language] code: [code snippet] .
2. Set up a pair programming session between [team member 1] and [team member 2] to
implement [specific feature or functionality].
3. Organize a brainstorming session to generate ideas and solutions for [problem or
challenge] faced by the development team.
4. Help establish a communication channel between [team member 1] and [team member 2]
to discuss and resolve [technical issue or question].
5. Assist in coordinating a code merge or integration between [team member 1]'s work and
[team member 2]'s work.

Code analytics:
1. Analyze the given codebase to identify frequently used libraries or dependencies:
[repository URL or codebase description] .

2. Generate a report on the complexity and maintainability of the following codebase:

[repository URL or codebase description] .
3. Identify trends or patterns in the development history of the given codebase: [repository
URL or codebase description] .

4. Analyze the codebase to identify potential areas of improvement or refactoring:

[repository URL or codebase description] .

5. Generate a summary of the coding styles and conventions used in the given codebase:
[repository URL or codebase description] .

Design pattern suggestions:

1. Based on the given [language] code, recommend a suitable design pattern to improve its
structure: [code snippet] .
2. Identify opportunities to apply the [design pattern] in the following [language] codebase:
[repository URL or codebase description] .
3. Suggest an alternative design pattern for the given [language] code that may provide
additional benefits: [code snippet] .
4. Explain how the [design pattern] can be applied in the given [language] code to address
[specific issue or challenge]: [code snippet] .
5. Compare the pros and cons of using [design pattern 1] vs [design pattern 2] in the context
of the given [language] code: [code snippet] .
 6. Provide examples of implementing the [design pattern] in [language] for the following
scenarios: [scenario list] .
7. Suggest a design pattern to optimize the performance of the given [language] code
handling [specific task or operation]: [code snippet] .
8. Evaluate the effectiveness of the [design pattern] in addressing the specific requirements
or constraints of the given [language] code: [code snippet] .
9. Propose a combination of design patterns that can be used to enhance the given
[language] code's architecture and functionality: [code snippet] .

Performance optimization:
1. Identify performance bottlenecks in the given [language] code and suggest optimizations:
[code snippet] .
2. Propose changes to the given [language] code to improve its memory usage: [code
snippet] .

3. Suggest ways to parallelize or distribute the following [language] code to improve its
performance: [code snippet] .
4. Compare the performance of the given [language] code using different optimization
techniques or libraries: [code snippet] .
5. Analyze the performance of the following [language] code in different environments or
hardware configurations: [code snippet] .

Security and privacy:

1. Evaluate the security of the given [language] code and suggest improvements: [code
snippet] .

2. Identify potential privacy risks in the following [language] code and recommend
mitigation strategies: [code snippet] .
3. Propose changes to the given [language] code to improve its resistance to common
security threats (e.g., SQL injection, XSS, CSRF): [code snippet] .
4. Analyze the security of the given [language] code in the context of [specific industry
standards or regulations]: [code snippet] .
5. Suggest encryption or hashing algorithms to secure sensitive data in the given [language]
code: [code snippet] .

Accessibility and inclusivity:

 1. Evaluate the accessibility of the given [web/mobile] app and suggest improvements to
comply with WCAG guidelines: [app URL or description] .
2. Propose changes to the given [web/mobile] app to improve its usability for users with
[specific disability or impairment]: [app URL or description] .
3. Suggest ways to make the given [web/mobile] app more inclusive and diverse in terms of
content, imagery, and language: [app URL or description] .
4. Analyze the accessibility of the given [web/mobile] app on various devices and screen
sizes: [app URL or description] .
5. Recommend tools or libraries to help improve the accessibility and inclusivity of the
given [web/mobile] app: [app URL or description] .

DevOps and CI/CD:

1. Design a CI/CD pipeline for the given [language] project based on its requirements and
constraints: [project description] .
2. Propose a strategy to automate the deployment of the given [language] application to
[cloud provider or environment]: [app description] .
3. Suggest improvements to the given [language] project's build and deployment process to
increase efficiency: [project description] .
4. Compare the advantages and disadvantages of different containerization technologies
(e.g., Docker, Kubernetes, Podman) for the given [language] project: [project description] .
5. Identify opportunities to optimize the given [language] project's infrastructure and
resource usage using cloud-native technologies: [project description] .

Remote work and collaboration:

1. Suggest tools and best practices for remote collaboration among the members of a
[language] development team.
2. Propose strategies to improve communication and coordination between distributed team
members working on a [language] project.
3. Recommend a workflow for managing and prioritizing tasks for a remote [language]
development team.
4. Suggest ways to maintain team morale and motivation among remote [language]
developers during a long-term project.
5. Share tips for organizing and facilitating effective remote meetings for a [language]
development team.
 6. Propose techniques for remote pair programming and code review sessions among
distributed [language] developers.

Open-source contribution:
1. Identify suitable open-source [language] projects for a developer with [specific skills or
interests].
2. Suggest open issues or feature requests in the following [language] open-source project
that match my skill set: [repository URL or project description] .
3. Recommend best practices for contributing to [language] open-source projects as a new
or inexperienced contributor.
4. Provide guidance on navigating the codebase and development process of the given
[language] open-source project: [repository URL or project description] .
5. Explain how to prepare and submit a pull request for the given [language] open-source
project: [repository URL or project description] .

Technical documentation:
1. Write an API reference for the following [language] code: [code snippet] .
2. Create a user guide for the given [software or tool] that covers installation, configuration,
and basic usage.
3. Write a comprehensive test plan for the given [language] code, including test cases and
scenarios: [code snippet] .
4. Develop a FAQ section that addresses common questions and issues related to the given
[language] project or tool.
5. Produce a clear and concise overview of the architecture and design of the given
[language] project or system: [project description] .

API design and development:

1. Design an API for a [type of application or service] that supports the following
operations: [list of operations] .
2. Propose a RESTful API structure for the given [language] code that follows best
practices: [code snippet] .
3. Suggest improvements to the following API design to enhance its usability, performance,
or security: [API description] .
4. Write a [language] code to interact with the following API: [API documentation or reference] .
 5. Compare different API authentication and authorization mechanisms (e.g., OAuth, JWT,
API keys) for the given [language] project: [project description] .

Integration and interoperability:

1. Suggest a strategy for integrating the given [language] code with [external system or
API]: [code snippet] .
2. Identify potential challenges and solutions for interoperability between the following
systems or technologies: [system or technology list] .
3. Propose a data transformation or mapping solution for the given [language] code to
interface with [external data source or format]: [code snippet] .
4. Recommend best practices for building and maintaining a [language] codebase that
integrates with multiple third-party services or APIs.
5. Evaluate the compatibility and performance of the given [language] code when
interacting with [specific technology or platform]: [code snippet] .

Technical interview preparation:

1. Suggest [language] coding exercises or challenges to practice for a technical interview.
2. Share tips and advice on how to approach and solve [language] coding problems during a
technical interview.
3. Provide examples of common [language] technical interview questions and their
solutions.
4. Conduct a mock [language] technical interview, including problem-solving, coding, and
explanation of thought process.
5. Evaluate and provide feedback on my performance during a [language] technical
interview, including areas for improvement and strengths.

Code generation and scaffolding:

1. Generate a [language] code template for a [type of application or service] that follows
best practices: [application or service description] .
2. Create a boilerplate [language] project structure for a [type of application] that includes
necessary configuration files and dependencies: [application description] .
3. Suggest a code scaffolding tool or library for the given [language] that helps streamline
the development process.
 4. Generate a CRUD (Create, Read, Update, Delete) [language] code for a [type of
application or service] that interacts with a [type of database]: [application or service
description] .

5. Provide a [language] code snippet that demonstrates the usage of a [library or framework]
to build a [specific feature or functionality]: [library or framework name] .

Technical leadership and mentoring:

1. Share best practices for leading and managing a [language] development team.
2. Suggest strategies for mentoring and coaching junior [language] developers to help them
grow and succeed.
3. Propose techniques for creating a culture of continuous learning and improvement within
a [language] development team.
4. Recommend approaches to balancing technical debt and feature development in a
[language] project.
5. Share advice on how to effectively communicate technical decisions and trade-offs to
non-technical stakeholders.

Code readability and style:

1. Evaluate the readability of the given [language] code and suggest improvements: [code
snippet] .

2. Propose a consistent coding style for the given [language] code that aligns with best
practices: [code snippet] .
3. Compare different [language] code formatting tools or linters and recommend one that
best suits the given project: [project description] .
4. Suggest ways to refactor the given [language] code to make it more concise and
maintainable: [code snippet] .
5. Share advice on how to write clean and self-documenting [language] code that is easy for
others to understand and maintain.

Career advice for software developers:

1. Recommend strategies for building a strong and diverse [language] development skill set.
2. Share advice on how to create an effective and compelling software developer portfolio.
3. Suggest networking opportunities or resources for [language] developers to connect with
peers and potential employers.
 4. Provide tips for negotiating a job offer or promotion as a [language] developer.
5. Share advice on how to transition from a different technical role to a [language]
development role.

Developer productivity:
1. Recommend tools and techniques to improve productivity for a [language] developer.
2. Suggest ways to minimize distractions and maintain focus during [language]
development tasks.
3. Share strategies for effectively managing and prioritizing tasks in a [language]
development project.
4. Propose techniques for estimating and tracking the time required for various [language]
development tasks.
5. Provide advice on how to maintain a healthy work-life balance as a [language] developer.

Testing and quality assurance:

1. Design a test suite for the given [language] code that covers various test scenarios and
edge cases: [code snippet] .
2. Recommend best practices for writing and maintaining unit tests for a [language]
codebase.
3. Suggest strategies for automating regression testing in the given [language] project:
[project description] .

4. Compare different [language] testing frameworks and recommend one that best suits the
given project: [project description] .
5. Share advice on how to incorporate continuous testing and quality assurance into the
development process for a [language] project.