AI Prompts for Resolving Async Code Stalls

Please analyze the following async function: [PASTE FUNCTION]. Identify any potential issues that could prevent the function from resolving or rejecting as expected. Consider aspects such as error handling, promise chaining, and any asynchronous operations that may not be properly awaited. Provide a detailed explanation of your findings and suggest possible solutions to address the identified problems.

Examine the following code snippet for promise handling: [PASTE SNIPPET]. Identify any instances where resolve or reject calls are missing, which could potentially lead to an infinite loading state. Please provide a detailed analysis of the code, highlighting specific lines where these calls should be added, and explain how their absence affects the promise's behavior. Additionally, suggest any improvements or best practices for handling promises in this context.

Please inspect the following async operation: [PASTE OPERATION]. Analyze the error handling mechanisms in place and determine if they are sufficient to prevent issues during resolution or rejection. Specifically, identify any potential failure points and suggest improvements or additional error handling strategies that could enhance the robustness of this operation. Provide a detailed explanation of your findings and recommendations in a structured format.

Please analyze the following section of code: [PASTE CODE]. Identify any potential misuses of the 'await' keyword that could result in unresolved promises. Provide a detailed explanation of each misuse you find, including the specific lines of code where the issues occur, the potential impact on the application's performance or functionality, and suggestions for how to correct these issues. Additionally, summarize best practices for using 'await' effectively in asynchronous programming.

Please review the following dependencies for my async function: [PASTE DEPENDENCIES]. Analyze each dependency to determine if any could potentially cause the function to hang indefinitely. Provide a detailed explanation of how each dependency might lead to this issue, including any common pitfalls or scenarios that could arise. Additionally, suggest possible solutions or workarounds to mitigate these risks and ensure the function operates smoothly.

In the following async function: [PASTE FUNCTION], identify the appropriate location to add a resolve call to ensure that the function completes successfully. Explain the reasoning behind your choice and describe how this addition will impact the function's behavior. Additionally, provide an example of how the function should look after the resolve call has been added, highlighting any changes made to the original code.

Please review the following code: [PASTE CODE]. Identify the areas where reject logic can be effectively implemented to handle errors in a robust manner. Provide specific recommendations on how to structure the reject logic, including any necessary error messages or fallback procedures. Additionally, explain the potential impact of these changes on the overall functionality and reliability of the code.

Please analyze the following async code: [PASTE CODE]. I need your help to identify the specific areas where the await usage may cause the code to hang. Provide a detailed explanation of the issues you find and suggest a refactored version of the code that prevents these hanging states. Additionally, outline best practices for using await in async functions to ensure smooth execution and performance.

Please review the following function: [PASTE FUNCTION]. Identify potential issues in the current error handling implementation and suggest specific improvements to ensure that errors are resolved or rejected correctly. Explain how these changes will enhance the reliability and robustness of the function. Additionally, provide examples of how to implement these improvements in the code, including any necessary adjustments to the function's structure or logic.

Please analyze the following dependencies: [PASTE DEPENDENCIES]. Identify any potential issues that could cause the async function to stall and provide specific recommendations on how to modify these dependencies to improve performance. Include details on any changes in the code structure, version updates, or alternative libraries that could be used. Additionally, explain how these modifications will enhance the overall functionality and responsiveness of the async function.

Please test the following updated async function: [PASTE FUNCTION]. Ensure that it resolves correctly and does not hang during execution. Provide a detailed report on the outcome, including any error messages or unexpected behavior encountered. Additionally, include the time taken for the function to resolve and any relevant observations about its performance.

Please check the following code for proper rejection handling when an error occurs: [PASTE CODE]. I need you to run the code and confirm that it rejects as expected under error conditions. Additionally, provide a brief explanation of how the rejection is handled, including any error messages that are returned and the conditions that trigger the rejection. If there are any issues or unexpected behaviors, please outline them clearly.

Please simulate error conditions for the following function: [PASTE FUNCTION]. Introduce a specific error scenario and evaluate how the function responds. Does it handle the error gracefully and reject appropriately? Provide a detailed analysis of the function's error handling, including any potential improvements that could enhance its robustness.

Please validate the following refactored code: [PASTE CODE]. Check that all await statements are functioning correctly and do not lead to any unresolved promises. Provide a detailed analysis of how the changes improve the code's performance and reliability, and suggest any further improvements if necessary. Additionally, include examples of potential edge cases that could arise and how they would be handled in this context.

Please run the function using the following dependencies: [PASTE DEPENDENCIES]. After executing the function, check if it completes successfully without hanging or encountering any dependency-related issues. Provide a detailed report on the execution results, including any error messages or warnings that may appear, and confirm whether the dependency fixes have resolved the hanging issue.

Based on the resolved issue regarding async functions hanging, please draft a new rule for my CLAUDE.md file. The rule should clearly outline the conditions under which async functions should be handled to prevent them from entering a hanging state. Include specific guidelines or best practices that developers should follow, along with examples of correct and incorrect implementations. Format the rule in a way that is easy to read and understand, ensuring it can be directly copied into the CLAUDE.md.

Please suggest a detailed comment to add above the following async function: [PASTE FUNCTION]. The comment should clearly explain the potential for infinite loading states that may occur during execution. Include specific scenarios that could lead to this issue, such as unhandled promises or network failures. Additionally, provide recommendations on how to mitigate these risks, such as implementing timeout logic or error handling strategies. Ensure the comment is concise yet informative, suitable for developers reviewing the code.

Help me create a comprehensive session-opener checklist to ensure my coding sessions start smoothly and prevent async code from stalling. The checklist should include key checks such as verifying the status of all necessary services, ensuring proper initialization of variables and functions, checking for any pending promises, and confirming that all required dependencies are loaded. Additionally, include reminders to review the project documentation for any recent changes that might affect the session. Format the checklist in a clear, numbered list for easy reference during my coding sessions.

Propose a detailed naming convention for asynchronous functions that clearly indicates their resolve and reject behavior. Include specific examples of how to name functions based on their purpose, such as using prefixes or suffixes to denote success or failure states. Additionally, explain the reasoning behind your proposed convention and how it can improve code readability and maintainability. Aim for a comprehensive guideline that can be easily adopted by a development team.

Design a project guard mechanism that automatically identifies and flags asynchronous functions that do not include resolve or reject calls. The guard should analyze the codebase for all async functions and generate a report detailing any instances where these calls are missing. Additionally, provide recommendations on how to implement resolve and reject calls effectively to ensure proper error handling and control flow. Format the output as a structured document with sections for findings, examples of problematic code, and suggested improvements.