AI Prompts for Resolving Infinite Loading States

Review the following async function code: [PASTE FUNCTION CODE]. Identify any instances where resolve or reject calls are missing, explain how these omissions could affect the function's behavior and error handling, and provide specific suggestions for correcting any identified issues to ensure the function operates as intended.

Analyze the following promise handling code: [PASTE CODE]. Identify any promises that are not being resolved or rejected, and for each unresolved promise, explain the potential impact on the application. Suggest specific ways to properly handle these promises and provide recommendations for improving the overall promise handling strategy in this code to enhance performance and reliability.

Inspect the changes made in Cascade mode during the last session. Provide a detailed list of all modified files, specifying the changes for each file, especially those related to asynchronous operations. Additionally, summarize how these changes impact the overall functionality and performance of the application.

Evaluate the event listener setup provided in the following code: [PASTE CODE]. Analyze each event listener to determine if any could potentially lead to an infinite loading state. For each listener identified, explain the specific conditions or logic that may cause this issue, and suggest possible solutions or modifications to prevent the infinite loading state from occurring. Present your analysis in a structured format, using bullet points for clarity and including examples where applicable.

Review the following error handling code: [PASTE CODE]. Identify any missing error handlers that could potentially lead to unresolved promises. Provide suggestions for improving the error handling logic to ensure that all possible errors are adequately managed. Explain how implementing these changes would enhance the robustness of the code and prevent issues during execution.

Identify where a resolve call should be added in the following async function: [PASTE FUNCTION CODE]. Explain your reasoning for placing the resolve call in that specific location and describe how this affects the function's behavior. Additionally, provide the corrected code and summarize any changes made, highlighting their importance in ensuring the function operates correctly.

Analyze the following code for missing reject statements: [PASTE CODE]. Identify the specific lines that require these statements and provide clear suggestions for where to insert them. Additionally, explain why each addition is necessary for effective error handling and flow control within the code.

Review the following promise chain: [PASTE CODE]. Identify any broken links that may prevent resolution and provide a corrected version of the code. Explain the changes you made and why they were necessary for the promise chain to function correctly. Additionally, outline best practices for structuring promise chains effectively, including examples where applicable.

Analyze the following code for potential event loop blockages: [PASTE CODE]. Identify specific areas where the event loop may become unresponsive and provide detailed suggestions for changes that can be made to ensure the event loop runs smoothly. Explain the reasoning behind each suggested change and how it will improve the performance of the code. Additionally, outline best practices that should be followed to prevent similar issues in the future.

Identify and resolve any conflicts causing asynchronous issues in the following Cascade changes: [PASTE CHANGES]. Analyze these changes for potential overlaps or dependencies that may lead to conflicts. For each identified conflict, provide a detailed explanation of why it is causing issues and outline the specific steps needed to resolve it. Additionally, recommend best practices that can be implemented to prevent similar conflicts from occurring in the future.

Execute the following async tests: [PASTE TEST CASES]. Verify that all promises resolve or reject as expected, and provide a detailed summary of the results. If any tests fail, include specifics such as the test case name, the expected outcome, and the actual outcome. Additionally, analyze the failures and suggest potential reasons for them, along with recommendations on how to address each issue.

Validate the user interface response for the following interactions: [DESCRIBE INTERACTIONS]. Ensure that the UI behaves as expected and does not enter an infinite loading state during these interactions. Provide a detailed report on any issues encountered, specifying the interaction that caused the problem, the expected behavior, and the actual behavior observed. Additionally, suggest potential fixes or improvements to enhance the user experience based on your findings.

Enable logging for promises using the following code: [PASTE LOGGING CODE]. After enabling the logging, review the logs to ensure that all promises are being handled correctly. Specifically, check for any unhandled promise rejections and confirm that each promise resolves or rejects as expected. Summarize your findings in a report, highlighting any issues and suggesting potential fixes.

Monitor the event loop using the following code: [PASTE MONITORING CODE]. Analyze its performance to confirm that it is processing without delays. Provide a detailed report on any detected delays, including the duration and frequency of each issue. Suggest potential optimizations if necessary, and summarize the overall health of the event loop along with recommendations for maintaining optimal performance.

Review the integrity of the following Cascade changes: [PASTE CHANGES]. Analyze these changes for potential asynchronous issues and confirm that all components are functioning as expected. Provide a detailed report on any discrepancies found, including specific areas that require attention or further testing. Additionally, suggest necessary actions to resolve any identified issues and ensure optimal performance.

Draft a rule for CLAUDE.md that mandates all asynchronous functions to include both resolve and reject calls. Explain the importance of handling both success and error cases in async functions to ensure robust error management. Additionally, provide at least two examples each of correct and incorrect implementations of async functions that adhere to this rule. Format the rule clearly and concisely, ensuring it is suitable for inclusion in a coding standards document.

Add detailed comments to the following async function: [PASTE FUNCTION CODE]. In your comments, explain the purpose of each section of the code, with a particular focus on the importance of the resolve and reject calls in managing asynchronous operations. Additionally, provide insights on how these calls affect the flow of the function and discuss any potential errors that may arise if they are not handled properly. Aim for clarity and thoroughness to ensure that someone unfamiliar with the code can understand its functionality.

Create a comprehensive checklist for reviewing asynchronous code prior to deployment. Ensure it covers essential aspects such as proper promise handling, appropriate error handling for all asynchronous functions, potential race conditions, and management of loading states to prevent infinite loading scenarios. Additionally, include points on testing the code in various scenarios and confirming that fallback mechanisms are in place. Format the checklist in a clear, bulleted list for easy reference.

Propose a set of naming conventions for asynchronous functions that clearly indicate their promise resolution behavior. For each convention, provide specific examples to illustrate practical application, and explain the rationale behind each naming choice. Discuss how these conventions improve code readability and maintainability, aiming for a comprehensive overview that can serve as a guideline for developers working with asynchronous code.

Design a project guard that automatically checks for missing resolve or reject calls in async functions within a JavaScript project. Outline the key components of the guard, including the method it will use to intercept async function calls and validate their promise handling. Describe the integration steps needed to incorporate this guard into the existing codebase, detailing any necessary configuration or setup. Additionally, provide examples of how the guard will report issues and suggest corrections, ensuring developers can easily identify and fix potential problems in their async code.