Code generation:
- Generate a boilerplate [language] code for a [class/module/component] named [name] with the following functionality: [functionality description].
- Create a [language] function to perform [operation] on [data structure] with the following inputs: [input variables] and expected output: [output description].
- Generate a [language] class for a [domain] application that includes methods for [methods list] and properties [properties list].
- Based on the [design pattern], create a code snippet in [language] that demonstrates its implementation for a [use case].
- Write a [language] script to perform [task] using [library/framework] with the following requirements: [requirements list].
Code completion:
- In [language], complete the following code snippet that initializes a [data structure] with [values]:
[code snippet]
. - Finish the [language] function that calculates [desired output] given the following input parameters:
[function signature]
. - Complete the [language] code to make an API call to [API endpoint] with [parameters] and process the response:
[code snippet]
. - Fill in the missing [language] code to implement error handling for the following function:
[code snippet]
. - Complete the following [language] loop that iterates over [data structure] and performs [operation]:
[code snippet]
.
Bug detection:
- Identify any potential bugs in the following [language] code snippet:
[code snippet]
. - Analyze the given [language] code and suggest improvements to prevent [error type]:
[code snippet]
. - Find any memory leaks in the following [language] code and suggest fixes:
[code snippet]
. - Check for any race conditions or concurrency issues in the given [language] code:
[code snippet]
. - Review the following [language] code for any security vulnerabilities:
[code snippet]
.
Code review:
- Review the following [language] code for best practices and suggest improvements:
[code snippet]
. - Analyze the given [language] code for adherence to [coding style guidelines]:
[code snippet]
. - Check the following [language] code for proper error handling and suggest enhancements:
[code snippet]
. - Evaluate the modularity and maintainability of the given [language] code:
[code snippet]
. - Assess the performance of the following [language] code and provide optimization suggestions:
[code snippet]
.
Natural language processing:
- Perform sentiment analysis on the following text: [text sample].
- Extract named entities from the following text: [text sample].
- Summarize the following article/document: [URL or text sample].
- Identify the main topic(s) of the following text: [text sample].
- Perform keyword extraction on the following text: [text sample].
API documentation generation:
- Generate API documentation for the following [language] code:
[code snippet]
. - Create a concise API reference for the given [language] class:
[code snippet]
. - Generate usage examples for the following [language] API:
[code snippet]
. - Document the expected input and output for the given [language] function:
[code snippet]
. - Produce a quick-start guide for using the following [language] library:
[code snippet]
.
Query optimization:
- Optimize the following SQL query for better performance:
[SQL query]
. - Analyze the given SQL query for any potential bottlenecks:
[SQL query]
. - Suggest indexing strategies for the following SQL query:
[SQL query]
. - Rewrite the following SQL query to use JOINs instead of subqueries for improved performance:
[SQL query]
. - Optimize the following NoSQL query for better performance and resource usage:
[NoSQL query]
. - Identify any inefficiencies in the given database schema that may be affecting query performance:
[schema description]
. - Suggest partitioning or sharding strategies for the following large-scale database query:
[SQL or NoSQL query]
. - Compare the performance of the given SQL query using different database engines (e.g., MySQL, PostgreSQL, Oracle):
[SQL query]
.
Chatbots and conversational AI:
- Create a conversational flow for a customer support chatbot that handles [issue or inquiry type].
- Design a chatbot interaction that helps users find [product or service] based on their preferences and requirements.
- Develop a conversational script for a chatbot that guides users through the [onboarding process or feature setup].
- Implement a chatbot that can answer frequently asked questions about [topic or domain].
- 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:
- Generate a UI mockup for a [web/mobile] application that focuses on [user goal or task].
- Suggest improvements to the existing user interface of [app or website] to enhance [usability, accessibility, or aesthetics].
- Design a responsive user interface for a [web/mobile] app that adapts to different screen sizes and orientations.
- Create a wireframe for a [web/mobile] app that streamlines user workflows for [specific use case].
- Design a UI component library for a [web/mobile] app that adheres to [design system or style guide].
Automated testing:
- Generate test cases for the following [language] function based on the input parameters and expected output:
[function signature]
. - Create a test script for the given [language] code that covers [unit/integration/system] testing:
[code snippet]
. - Generate test data for the following [language] function that tests various edge cases:
[function signature]
. - Design a testing strategy for a [web/mobile] app that includes [unit, integration, system, and/or performance] testing.
- Write a test suite for a [language] API that verifies its functionality and performance under different conditions.
Code refactoring:
- Suggest refactoring improvements for the following [language] code to enhance readability and maintainability:
[code snippet]
. - Identify opportunities to apply [design pattern] in the given [language] code:
[code snippet]
. - Optimize the following [language] code for better performance:
[code snippet]
. - Refactor the given [language] code to improve its modularity and reusability:
[code snippet]
. - Propose changes to the given [language] code to adhere to [coding style or best practices]:
[code snippet]
.
Algorithm development:
- Suggest an optimal algorithm to solve the following problem: [problem description].
- Improve the efficiency of the given algorithm for [specific use case]:
[algorithm or pseudocode]
. - Design an algorithm that can handle [large-scale data or high-throughput] for [specific task or operation].
- Propose a parallel or distributed version of the following algorithm to improve performance:
[algorithm or pseudocode]
. - Evaluate the time and space complexity of the given algorithm and suggest optimizations:
[algorithm or pseudocode]
.
Code translation:
- Translate the following [source language] code to [target language]:
[code snippet]
. - Convert the given [source language] class or module to [target language] while preserving its functionality and structure:
[code snippet]
. - Migrate the following [source language] code that uses [library or framework] to [target language] with a similar library or framework:
[code snippet]
. - Rewrite the given [source language] algorithm in [target language] with equivalent performance characteristics:
[algorithm or pseudocode]
. - Adapt the following [source language] code snippet to [target language] while adhering to [target language's best practices]:
[code snippet]
. - Translate the given [source language] function that handles [specific task or operation] to [target language]:
[code snippet]
.
Personalized learning:
- Curate a list of resources to learn [programming language or technology] based on my current skill level: [beginner/intermediate/advanced].
- Recommend a learning path to become proficient in [specific programming domain or technology] considering my background in [existing skills or experience].
- Suggest project ideas or coding exercises to practice and improve my skills in [programming language or technology].
- Recommend online courses, tutorials, or books that focus on [specific topic or concept] in [programming language or technology].
- Identify areas of improvement in my coding skills based on the following [language] code:
[code snippet]
.
Technical writing:
- Write a tutorial on how to implement [specific feature or functionality] using [programming language or technology].
- Create a step-by-step guide on setting up and configuring [tool or software] for [specific use case or environment].
- Draft a README file for a [programming language or technology] project that includes an overview, installation instructions, and usage examples.
- Write a clear and concise explanation of the [algorithm or concept] in [programming language or technology].
- Create a troubleshooting guide for common issues and their solutions when working with [programming language, library, or framework].
Requirement analysis:
- Interpret the following project requirements and suggest a high-level architecture or design:
[requirements description]
. - Identify potential risks or challenges in implementing the given project requirements:
[requirements description]
. - Suggest a prioritization strategy for the following list of project requirements:
[requirements list]
. - Based on the given project requirements, recommend a suitable [programming language, framework, or technology]:
[requirements description]
. - Estimate the development effort and resources needed to implement the following project requirements:
[requirements description]
.
Project planning:
- Estimate the timeline and milestones for a project with the following requirements:
[requirements description]
. - Propose a development methodology (e.g., Agile, Scrum, Waterfall) for a project with the following characteristics:
[project description]
. - Suggest a team structure and roles for a project with the following scope and requirements:
[project description]
. - Identify dependencies and potential bottlenecks in a project with the following requirements and constraints:
[requirements description]
. - 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:
- Automatically categorize and prioritize the following list of reported issues:
[issue list]
. - Suggest potential solutions for the following reported issue:
[issue description]
. - Identify the root cause of the given issue and propose steps to prevent its recurrence:
[issue description]
. - Estimate the effort required to resolve the following issue and its impact on the project timeline:
[issue description]
. - Propose a workaround or temporary fix for the following critical issue while a permanent solution is being developed:
[issue description]
.
Code visualization:
- Generate a UML diagram for the following [language] code:
[code snippet]
. - Create a flowchart or visual representation of the given [language] algorithm:
[algorithm or pseudocode]
. - Visualize the call graph or dependencies of the following [language] code:
[code snippet]
. - Generate a data flow diagram for the given [language] code that demonstrates how data is processed:
[code snippet]
. - Create an interactive visualization of the runtime behavior or performance of the following [language] code:
[code snippet]
.
Data visualization:
- Generate a bar chart that represents the following data:
[data or dataset description]
. - Create a line chart that visualizes the trend in the following time series data:
[data or dataset description]
. - Design a heatmap that represents the correlation between the following variables:
[variable list]
. - Visualize the distribution of the following dataset using a histogram or box plot:
[data or dataset description]
. - Generate a scatter plot that demonstrates the relationship between the following two variables:
[variable 1]
and[variable 2]
.
Prototyping:
- Generate a proof-of-concept [language] code for a [project idea or feature] based on the following requirements:
[requirements description]
. - Create a functional prototype of a [web/mobile] app that demonstrates [specific functionality or user flow].
- Develop a minimal viable product (MVP) for a [product or service] based on the following specifications:
[specifications description]
. - Implement a simple simulation or model of a [system or process] using [language or technology].
- Create a working demo of a [tool or feature] that showcases its potential benefits and use cases.
Collaborative coding:
- Facilitate a code review session between [team member 1] and [team member 2] for the following [language] code:
[code snippet]
. - Set up a pair programming session between [team member 1] and [team member 2] to implement [specific feature or functionality].
- Organize a brainstorming session to generate ideas and solutions for [problem or challenge] faced by the development team.
- Help establish a communication channel between [team member 1] and [team member 2] to discuss and resolve [technical issue or question].
- Assist in coordinating a code merge or integration between [team member 1]'s work and [team member 2]'s work.
Code analytics:
- Analyze the given codebase to identify frequently used libraries or dependencies:
[repository URL or codebase description]
. - Generate a report on the complexity and maintainability of the following codebase:
[repository URL or codebase description]
. - Identify trends or patterns in the development history of the given codebase:
[repository URL or codebase description]
. - Analyze the codebase to identify potential areas of improvement or refactoring:
[repository URL or codebase description]
. - Generate a summary of the coding styles and conventions used in the given codebase:
[repository URL or codebase description]
.
Design pattern suggestions:
- Based on the given [language] code, recommend a suitable design pattern to improve its structure:
[code snippet]
. - Identify opportunities to apply the [design pattern] in the following [language] codebase:
[repository URL or codebase description]
. - Suggest an alternative design pattern for the given [language] code that may provide additional benefits:
[code snippet]
. - Explain how the [design pattern] can be applied in the given [language] code to address [specific issue or challenge]:
[code snippet]
. - Compare the pros and cons of using [design pattern 1] vs [design pattern 2] in the context of the given [language] code:
[code snippet]
. - Provide examples of implementing the [design pattern] in [language] for the following scenarios:
[scenario list]
. - Suggest a design pattern to optimize the performance of the given [language] code handling [specific task or operation]:
[code snippet]
. - Evaluate the effectiveness of the [design pattern] in addressing the specific requirements or constraints of the given [language] code:
[code snippet]
. - Propose a combination of design patterns that can be used to enhance the given [language] code's architecture and functionality:
[code snippet]
.
Performance optimization:
- Identify performance bottlenecks in the given [language] code and suggest optimizations:
[code snippet]
. - Propose changes to the given [language] code to improve its memory usage:
[code snippet]
. - Suggest ways to parallelize or distribute the following [language] code to improve its performance:
[code snippet]
. - Compare the performance of the given [language] code using different optimization techniques or libraries:
[code snippet]
. - Analyze the performance of the following [language] code in different environments or hardware configurations:
[code snippet]
.
Security and privacy:
- Evaluate the security of the given [language] code and suggest improvements:
[code snippet]
. - Identify potential privacy risks in the following [language] code and recommend mitigation strategies:
[code snippet]
. - Propose changes to the given [language] code to improve its resistance to common security threats (e.g., SQL injection, XSS, CSRF):
[code snippet]
. - Analyze the security of the given [language] code in the context of [specific industry standards or regulations]:
[code snippet]
. - Suggest encryption or hashing algorithms to secure sensitive data in the given [language] code:
[code snippet]
.
Accessibility and inclusivity:
- Evaluate the accessibility of the given [web/mobile] app and suggest improvements to comply with WCAG guidelines:
[app URL or description]
. - Propose changes to the given [web/mobile] app to improve its usability for users with [specific disability or impairment]:
[app URL or description]
. - Suggest ways to make the given [web/mobile] app more inclusive and diverse in terms of content, imagery, and language:
[app URL or description]
. - Analyze the accessibility of the given [web/mobile] app on various devices and screen sizes:
[app URL or description]
. - 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:
- Design a CI/CD pipeline for the given [language] project based on its requirements and constraints:
[project description]
. - Propose a strategy to automate the deployment of the given [language] application to [cloud provider or environment]:
[app description]
. - Suggest improvements to the given [language] project's build and deployment process to increase efficiency:
[project description]
. - Compare the advantages and disadvantages of different containerization technologies (e.g., Docker, Kubernetes, Podman) for the given [language] project:
[project description]
. - Identify opportunities to optimize the given [language] project's infrastructure and resource usage using cloud-native technologies:
[project description]
.
Remote work and collaboration:
- Suggest tools and best practices for remote collaboration among the members of a [language] development team.
- Propose strategies to improve communication and coordination between distributed team members working on a [language] project.
- Recommend a workflow for managing and prioritizing tasks for a remote [language] development team.
- Suggest ways to maintain team morale and motivation among remote [language] developers during a long-term project.
- Share tips for organizing and facilitating effective remote meetings for a [language] development team.
- Propose techniques for remote pair programming and code review sessions among distributed [language] developers.
Open-source contribution:
- Identify suitable open-source [language] projects for a developer with [specific skills or interests].
- Suggest open issues or feature requests in the following [language] open-source project that match my skill set:
[repository URL or project description]
. - Recommend best practices for contributing to [language] open-source projects as a new or inexperienced contributor.
- Provide guidance on navigating the codebase and development process of the given [language] open-source project:
[repository URL or project description]
. - Explain how to prepare and submit a pull request for the given [language] open-source project:
[repository URL or project description]
.
Technical documentation:
- Write an API reference for the following [language] code:
[code snippet]
. - Create a user guide for the given [software or tool] that covers installation, configuration, and basic usage.
- Write a comprehensive test plan for the given [language] code, including test cases and scenarios:
[code snippet]
. - Develop a FAQ section that addresses common questions and issues related to the given [language] project or tool.
- Produce a clear and concise overview of the architecture and design of the given [language] project or system:
[project description]
.
API design and development:
- Design an API for a [type of application or service] that supports the following operations:
[list of operations]
. - Propose a RESTful API structure for the given [language] code that follows best practices:
[code snippet]
. - Suggest improvements to the following API design to enhance its usability, performance, or security:
[API description]
. - Write a [language] code to interact with the following API:
[API documentation or reference]
. - Compare different API authentication and authorization mechanisms (e.g., OAuth, JWT, API keys) for the given [language] project:
[project description]
.
Integration and interoperability:
- Suggest a strategy for integrating the given [language] code with [external system or API]:
[code snippet]
. - Identify potential challenges and solutions for interoperability between the following systems or technologies:
[system or technology list]
. - Propose a data transformation or mapping solution for the given [language] code to interface with [external data source or format]:
[code snippet]
. - Recommend best practices for building and maintaining a [language] codebase that integrates with multiple third-party services or APIs.
- Evaluate the compatibility and performance of the given [language] code when interacting with [specific technology or platform]:
[code snippet]
.
Technical interview preparation:
- Suggest [language] coding exercises or challenges to practice for a technical interview.
- Share tips and advice on how to approach and solve [language] coding problems during a technical interview.
- Provide examples of common [language] technical interview questions and their solutions.
- Conduct a mock [language] technical interview, including problem-solving, coding, and explanation of thought process.
- Evaluate and provide feedback on my performance during a [language] technical interview, including areas for improvement and strengths.
Code generation and scaffolding:
- Generate a [language] code template for a [type of application or service] that follows best practices:
[application or service description]
. - Create a boilerplate [language] project structure for a [type of application] that includes necessary configuration files and dependencies:
[application description]
. - Suggest a code scaffolding tool or library for the given [language] that helps streamline the development process.
- 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]
. - 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:
- Share best practices for leading and managing a [language] development team.
- Suggest strategies for mentoring and coaching junior [language] developers to help them grow and succeed.
- Propose techniques for creating a culture of continuous learning and improvement within a [language] development team.
- Recommend approaches to balancing technical debt and feature development in a [language] project.
- Share advice on how to effectively communicate technical decisions and trade-offs to non-technical stakeholders.
Code readability and style:
- Evaluate the readability of the given [language] code and suggest improvements:
[code snippet]
. - Propose a consistent coding style for the given [language] code that aligns with best practices:
[code snippet]
. - Compare different [language] code formatting tools or linters and recommend one that best suits the given project:
[project description]
. - Suggest ways to refactor the given [language] code to make it more concise and maintainable:
[code snippet]
. - 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:
- Recommend strategies for building a strong and diverse [language] development skill set.
- Share advice on how to create an effective and compelling software developer portfolio.
- Suggest networking opportunities or resources for [language] developers to connect with peers and potential employers.
- Provide tips for negotiating a job offer or promotion as a [language] developer.
- Share advice on how to transition from a different technical role to a [language] development role.
Developer productivity:
- Recommend tools and techniques to improve productivity for a [language] developer.
- Suggest ways to minimize distractions and maintain focus during [language] development tasks.
- Share strategies for effectively managing and prioritizing tasks in a [language] development project.
- Propose techniques for estimating and tracking the time required for various [language] development tasks.
- Provide advice on how to maintain a healthy work-life balance as a [language] developer.
Testing and quality assurance:
- Design a test suite for the given [language] code that covers various test scenarios and edge cases:
[code snippet]
. - Recommend best practices for writing and maintaining unit tests for a [language] codebase.
- Suggest strategies for automating regression testing in the given [language] project:
[project description]
. - Compare different [language] testing frameworks and recommend one that best suits the given project:
[project description]
. - Share advice on how to incorporate continuous testing and quality assurance into the development process for a [language] project.