AI Prompts for Resolving Incomplete Code Outputs

Please analyze the following .cursorrules file content: [PASTE CONTENT]. Identify any rules that could lead to incomplete code generation and provide a detailed explanation of how each rule affects the output. Additionally, suggest possible modifications or improvements to ensure more complete and accurate code generation. Format your response in a clear and structured manner, highlighting the key findings and recommendations.

Please provide a comprehensive list of all currently open files in the project. For each file, analyze its size and complexity, and identify any that may be contributing to the issue of incomplete code generation. Include specific details such as the file name, size in kilobytes, number of lines of code, and any notable complexity factors, such as the use of advanced programming constructs or dependencies. Summarize your findings and suggest potential solutions to address the identified issues.

Please analyze the following recent changes in my project: [PASTE CHANGES]. Identify any modifications that could potentially lead to incomplete code outputs. For each change, provide a brief explanation of why it may cause issues, and suggest possible solutions or adjustments to ensure the code functions correctly. Additionally, summarize the overall impact of these changes on the project's performance and reliability.

Evaluate the current session length and analyze its potential impact on the quality of code output. Provide a detailed assessment of how the duration of the session may affect context retention and the likelihood of incomplete code generation. Include recommendations for optimal session length to maintain context and improve output quality, and suggest any strategies to mitigate issues related to session length.

Please analyze the following function code: [PASTE FUNCTION]. Determine if the complexity or size of this function could be contributing to issues with incomplete output during generation. Provide a detailed assessment of the function's time and space complexity, including any specific elements that might be problematic. Additionally, suggest potential optimizations or refactoring strategies that could improve the function's performance and ensure smoother generation.

Please simplify the logic of the following function: [PASTE FUNCTION]. Focus on making the code more concise while maintaining its original functionality. Explain any changes you make and provide a brief summary of how the new version improves readability or efficiency. The final output should be a clear and well-structured version of the function that is easy to understand.

Identify the function provided: [PASTE FUNCTION] and analyze its structure. Determine which segments can be effectively separated into smaller, more manageable functions. Explain the reasoning behind each split, including how it improves readability, maintainability, and the overall functionality of the code. Provide examples of the new smaller functions and describe their specific roles within the larger context of the original function.

Please review the following project rules from the .cursorrules file: [PASTE CONTENT]. Analyze the current rules and suggest specific adjustments that will enhance the code generation process. Focus on identifying any gaps or limitations in the existing rules, and provide clear recommendations on how to modify them to ensure that the generated code is complete and functional. Format your response as a detailed report, outlining each adjustment and the rationale behind it.

Identify the unnecessary files currently open in the project and provide a list of them. For each file, explain why it is not needed and suggest which files should be closed to optimize performance. Additionally, analyze the remaining open files to ensure they are essential for the code generation process, and provide recommendations for any further optimizations that can be made to enhance load efficiency and code completion.

Please restart the session to refresh the context. After the restart, attempt to generate the code for the following function: [PASTE FUNCTION]. Ensure that the generated code is complete, follows best practices, and includes comments explaining the logic behind each part of the function. If there are any errors or issues in the previous attempt, identify and correct them in this new output.

Please run tests on the following function: [PASTE FUNCTION]. Verify that all components of the function are correctly implemented and that they pass all specified tests. Provide a detailed report that includes the results of each test case, any errors encountered, and suggestions for improvements if any tests fail. Additionally, summarize the overall performance of the function based on the test results.

Please review the following code for the function: [PASTE FUNCTION]. Ensure that all placeholder comments have been removed and that the code is complete and functional. Additionally, provide feedback on any potential improvements or optimizations that could be made to enhance the code's performance or readability. Summarize your findings in a brief report, highlighting any issues found and suggested changes.

Please validate the contents of the .cursorrules file provided below: [PASTE CONTENT]. Check for any inconsistencies or errors that may affect the complete code generation process. Summarize your findings in a report that includes specific areas where the rules may need adjustments or improvements, and provide recommendations for ensuring alignment with best practices in code generation.

Please execute the following function: [PASTE FUNCTION]. Verify that it produces the expected output and does not result in any errors. Additionally, provide a brief analysis of the function's performance, including any potential edge cases that may not be handled correctly. If there are discrepancies between the actual output and the expected output, explain what those discrepancies are and suggest possible improvements to the function.

Please analyze the session logs from [DATE RANGE] to verify whether the issue of stopping mid-function has been resolved. Focus on identifying any instances where the function execution was interrupted and provide a summary of your findings. Include details such as timestamps, error messages, and any patterns observed in the logs. Additionally, suggest any further actions or monitoring that may be necessary to ensure the issue does not recur.

Please suggest a new rule for CLAUDE.md that addresses the issue of incomplete code generation. The rule should include specific guidelines on how to ensure that generated code is complete and functional. Additionally, outline the criteria that should be used to evaluate the completeness of code outputs and provide examples of common pitfalls that lead to incomplete code. Format your response as a detailed rule description that can be easily referenced in future discussions.

Please add detailed comments to the following code: [PASTE CODE]. The comments should explain the purpose of each function, the logic behind key sections, and any important variables or data structures used. Ensure that the comments are clear enough for someone unfamiliar with the code to understand its functionality and flow. Additionally, highlight any areas that may require further attention or improvement to prevent incomplete outputs in the future.

Create a comprehensive checklist for starting coding sessions to ensure all necessary conditions for complete code generation are met. The checklist should include items such as verifying the development environment setup, confirming access to required libraries and frameworks, ensuring all dependencies are installed, and reviewing the project specifications for clarity. Additionally, include steps for testing and debugging protocols to follow during the session. Format the checklist in a clear, organized manner with bullet points for easy reference.

Help me establish effective naming conventions for functions and variables that enhance code readability and facilitate complete code generation. Consider best practices in programming languages such as [LANGUAGE] and focus on clarity, consistency, and meaningfulness. Provide examples of naming conventions for different types of functions (e.g., utility functions, event handlers) and variables (e.g., constants, temporary variables). Additionally, outline any guidelines for naming conventions that can help avoid common pitfalls and improve collaboration among team members.

Please suggest a comprehensive list of project guards that can be implemented in the .cursorrules file to prevent incomplete code outputs. Include specific examples of guards that address common issues such as syntax errors, missing dependencies, and incomplete function definitions. For each guard, provide a brief explanation of its purpose, how it works, and any potential limitations. Format the response as a structured document with headings for each guard type and bullet points for key details.