AI Prompts for Resolving Infinite Loading States

Please analyze the current codebase and identify all asynchronous functions present. For each function, highlight any promises that lack both resolve and reject handlers. Explain the potential implications of these unhandled promises on the user interface, particularly how they might contribute to the UI becoming unresponsive or hanging. Provide examples of how this issue could manifest in user experience and suggest best practices for handling promises effectively.

Trace the execution flow of the asynchronous code provided. Identify the specific point where the flow stops and does not proceed to either resolve or reject. Explain in detail the reasons for the blockage, including any potential issues with promises, callbacks, or event listeners that may be causing the halt. Additionally, suggest possible solutions or debugging steps to resolve the issue and ensure the code executes as intended.

Please analyze the most recent changes made to the asynchronous functions in the codebase. Identify specific modifications that may lead to promises being stuck in a loading state, neither resolving nor rejecting. For each identified change, explain how it impacts the overall execution flow and what potential issues it could create in terms of application performance or user experience. Provide a detailed summary of your findings, including examples where applicable, to help diagnose the problem effectively.

Please examine the error handling mechanisms implemented in the asynchronous functions of the codebase. Identify any missing or incorrect error handlers that could potentially lead to unresolved promises. Provide a detailed analysis of each function, highlighting specific areas where error handling is inadequate, and suggest improvements or best practices to ensure robust error management. Additionally, summarize the potential impact of these issues on overall application performance and user experience.

Please review the following content from my CLAUDE.md file: [PASTE CONTENT]. Confirm your understanding of the rules related to async operations outlined in the document. Identify any specific rules that are not being followed, and provide detailed feedback on how these violations could impact the overall functionality. Additionally, suggest any improvements or corrections to ensure compliance with the established rules.

Identify all asynchronous functions in the provided code that are missing either resolve or reject handlers for their promises. For each identified function, add the appropriate handlers to ensure that all promises resolve or reject correctly. Additionally, provide a brief explanation of why it's important to handle promise resolution and rejection in asynchronous functions, and include examples of how the updated functions should look after the handlers are added. Make sure to maintain the overall functionality of the code while improving its reliability.

Analyze the provided code to identify where the execution flow is getting stuck. Explain the specific reasons for the blockage and suggest modifications to ensure that all promises are correctly resolved or rejected. Provide a detailed breakdown of the changes needed, including any relevant code snippets, and outline the expected behavior after implementing these changes. Additionally, describe any potential edge cases that should be considered to prevent similar issues in the future.

Identify the specific lines in the asynchronous code that are causing it to hang. Analyze the logic and flow of the code to determine why the promises are not resolving or rejecting as expected. Refactor these lines to ensure proper handling of the promises, including adding necessary error handling and ensuring that all asynchronous operations are awaited correctly. Provide a clear explanation of the changes made and how they improve the functionality of the code. Format your response as a code snippet with comments explaining each change.

Please enhance the error handling in the following async functions: [FUNCTION_NAME_1], [FUNCTION_NAME_2], and [FUNCTION_NAME_3]. Ensure that all potential errors are caught and handled appropriately to prevent unresolved promises. Provide a detailed explanation of the changes made, including how each error is managed and any specific error messages that are returned. Additionally, include examples of how to test these functions to verify that errors are handled correctly.

Please analyze the recent code changes in the project and identify any modifications that have introduced unresolved promises. Once identified, revert these changes and provide a detailed explanation of the impact of each change on the overall functionality and performance of the application. Additionally, include recommendations for preventing similar issues in the future, and suggest best practices for handling promises effectively in the codebase.

Please run a series of tests on the asynchronous functions in my codebase to verify that all promises are resolving or rejecting correctly. Provide a detailed report of the test results, including any errors encountered and the specific functions being tested. Additionally, confirm that the user interface remains responsive during these tests. If any issues are found, please suggest potential solutions or improvements to ensure proper functionality.

Please simulate the user interactions that previously caused the loading state in the application. Confirm whether the user interface now functions smoothly without hanging. Provide a detailed comparison of the UI before and after the resolution, highlighting any improvements in responsiveness and user experience. Include specific scenarios that were tested, the outcomes of each interaction, and any relevant metrics that demonstrate the changes.

Please generate and review the execution logs for the asynchronous functions in my code. Confirm that all promises either reach a resolved or rejected state, and provide a detailed log output for each function executed. Include timestamps for each log entry, the status of each promise, and any relevant error messages if a promise is rejected. Additionally, summarize any patterns or issues observed in the logs that may indicate potential problems in the code execution.

Please recreate the exact scenario that previously led to the infinite loading state in the application. Detail each step you take to replicate the issue, including any specific inputs or configurations used. After reproducing the scenario, confirm whether the issue still occurs or if it has been resolved. Provide evidence of your findings, such as screenshots or logs, that demonstrate the application's behavior during your testing.

Please validate the enhanced error handling mechanisms in the application. Ensure that all potential errors are caught and handled appropriately, and that no promises are left unresolved. Provide a detailed report on the types of errors encountered during testing, how they were handled, and any instances where promises may have been left unresolved. Include recommendations for improvements if any issues are found, and summarize the overall effectiveness of the error handling in a structured format.

Please draft a new rule for the CLAUDE.md file that mandates all asynchronous functions to include both resolve and reject handlers. The rule should clearly outline the rationale behind this requirement, including potential issues that can arise from not having these handlers. Additionally, provide an example of a properly structured async function that adheres to this rule, along with a brief explanation of how the resolve and reject handlers function within the context of the example. Format the response as a markdown section that can be directly added to the CLAUDE.md file.

Please provide a code comment that should be inserted above each asynchronous function in JavaScript. The comment should remind developers to include both resolve and reject handlers in the function. Ensure the comment is clear and concise, and format it as a single line of code. The final output should be suitable for direct inclusion in a codebase.

Create a comprehensive checklist to follow at the beginning of any session involving asynchronous code. The checklist should include steps to ensure that all promises are properly handled, including resolving or rejecting as expected. Cover key aspects such as error handling, timeout settings, and ensuring that all async functions are awaited appropriately. Format the checklist in a clear, numbered list for easy reference, and include examples where applicable to illustrate best practices.

Please define a project convention that mandates all asynchronous functions must include error handling. Specify the exact wording for this convention, ensuring it clearly outlines the expectations for developers regarding error handling in async functions. Include examples of acceptable error handling practices and explain the importance of this convention in maintaining code quality and reliability. Additionally, suggest ways to enforce this convention within the project team.

Create a session opener template that emphasizes the importance of verifying all asynchronous code resolves or rejects. The template should include a clear reminder to check for potential infinite loading states and ensure that error handling is properly implemented. Additionally, provide a brief explanation of why this verification is crucial for maintaining application performance and user experience. Format the template as a structured outline with headings and bullet points for clarity, and include placeholders for specific session details such as [SESSION DATE], [SESSION TOPIC], and [TEAM MEMBER NAMES].