AI Prompts for Diagnosing Async Timing Bugs

Please provide the exact output of the state update function from the last run of the application. Compare this output to the expected output based on the defined behavior in the component. Identify any discrepancies between the two outputs and explain the potential implications of these differences on the application's performance and functionality.

Please provide the error message you received when attempting to write to the cache: [ERROR MESSAGE]. Analyze this error to determine if it is related to asynchronous timing issues. Include details on potential race conditions and suggest possible solutions or workarounds to address the issue. Format your response as a structured report with sections for the error analysis, identified issues, and recommendations.

Please interpret the original instruction regarding state updates before retrying the last operation. Clearly outline your understanding of the instruction, highlighting any potential misunderstandings or ambiguities you identify. Provide a structured summary that includes key points and clarifications to ensure accurate execution of the operation.

Compare the expected state behavior after the update with the actual behavior that was observed. Clearly outline the expected state as [EXPECTED STATE] and the actual state recorded as [ACTUAL STATE]. Additionally, provide an analysis of any discrepancies between these two states, including potential reasons for the differences and their implications on the overall system performance. Format your response in a clear table with columns for "Expected State," "Actual State," and "Analysis.

Identify the specific rule or constraint that was violated during the async operation. Quote the exact clause from the documentation that outlines this constraint.

Please modify the state update function in [FILE] at line [LINE] to ensure it waits for the previous state to resolve before proceeding. Provide a detailed explanation of the changes made and show me the diff of the code before applying the modifications. Additionally, outline any potential issues that could arise from this change and how they can be mitigated.

Rewrite the async function located at [FILE] on line [LINE] to include a constraint that ensures all state updates are completed before any subsequent operations are executed. Please provide the revised code along with a brief explanation of how the constraint works and why it is necessary for preventing race conditions.

Modify the cache write logic in [FILE] at [LINE] to include a verification check that ensures the state is ready before performing the write operation. Please provide the updated code snippet along with a brief explanation of how this change helps prevent race conditions. Additionally, outline any potential impacts this modification may have on performance or functionality.

Enforce a specific format for state updates in [FILE] at line [LINE] to prevent race conditions. Please provide a detailed description of the required format, including examples of both the current and the corrected state updates. Additionally, outline the changes made to ensure compliance with this format and explain how these changes will help mitigate race conditions.

Review the imports in [FILE] for the async function. Ensure that all dependencies are correctly imported and identify any missing or incorrect imports. Provide a detailed list of the issues found, including the specific imports that need to be added or corrected, and suggest the appropriate changes needed to resolve these issues.

Please execute the state update function for the use-case of [USE-CASE NAME] and verify that it completes without any errors. After execution, log the output and confirm that the expected state of [EXPECTED STATE] is achieved. Provide a summary of any discrepancies or errors encountered during the process.

Please provide a detailed comparison of the cache write logic before and after the fix for the race condition issue. Highlight the specific lines of code that have changed and explain how these modifications address the asynchronous timing problems. Additionally, summarize any potential impacts these changes may have on overall system performance and reliability.

Replay the original scenario that caused the async timing bug in the [APPLICATION NAME]. Document the steps taken to reproduce the issue and verify that the scenario now completes successfully without introducing new errors. Additionally, provide a summary of any changes made to resolve the issue and explain how these changes prevent future race conditions.

Please verify the edge case behavior for the scenario that previously triggered the async timing bug in the application. Specifically, test the application under conditions that may lead to race conditions and confirm that it behaves as expected without any timing issues. Document the results of your tests, including any discrepancies observed and the steps taken to reproduce the issue.

Please confirm the output state after applying the fix for the race conditions in the [USE-CASE NAME]. Compare the actual output against the expected state defined in the requirements document. Provide a detailed report highlighting any discrepancies, including specific values and conditions that were checked, and suggest further actions if the output does not match the expected state.

Please provide the exact session-opening constraint for the project related to preventing race conditions in async operations. Use the following format: 'Before any async operation: verify that all state updates are complete. If any state is pending, stop and log an error before continuing. Never proceed with async operations without confirming state readiness.' Ensure that the response is clear and concise, and formatted as a single coherent statement.

Draft a conversation-starter template for discussing state update verification in software development. The template should include a clear guideline: 'Before executing state updates, confirm that the previous state has been fully resolved. If it has not been resolved, log the current state and halt execution.' Additionally, provide examples of scenarios where this verification is crucial and outline potential consequences of skipping this step.

Draft a project specification message regarding cache write consistency for the use case of preventing race conditions. The message should clearly state that all cache writes must include a check for state readiness. If the state is not ready, the write should be deferred until it is confirmed. Additionally, provide a brief explanation of the importance of this check in maintaining data integrity and preventing potential issues in the system. Format the message in a clear and concise manner suitable for team communication.

Please establish a naming convention for async functions that indicates they require state readiness checks. Specifically, I would like you to suggest a prefix that can be used for these functions, such as 'READY_', and explain the rationale behind this choice. Additionally, provide examples of how this convention can be applied in code, and discuss any potential benefits of using this naming convention in preventing race conditions.

Please create a self-check request for the agent to ensure that before any asynchronous operation, all dependencies are resolved and the state is ready. If the dependencies are not resolved or the state is not ready, log the issue and halt execution. Format the output as a clear checklist that can be easily referenced during the development process.