AI Prompts for Eliminate Unnecessary Abstractions

Quote the exact output from the function you created in [FILE]:[LINE]. This function was intended to be a direct implementation of the original requirement, which specified that the logic should be implemented directly without any abstraction. Provide a comparison between this output and the original requirement, highlighting how the abstraction deviates from the intended implementation.

Paste the code snippet from [FILE] where the AI generated a wrapper function for logic that is only used once. Analyze this snippet to identify unnecessary complexity and explain how it could be simplified. Provide specific recommendations on how to refactor the code to eliminate the wrapper function while maintaining functionality. Include a comparison of the original and refactored code for clarity.

Please explain your understanding of my original instruction regarding the implementation of [SPECIFIC FUNCTION]. What was the intended outcome of this instruction? Provide a detailed interpretation, including any assumptions you made and how they relate to the desired results. Additionally, outline any potential challenges or misunderstandings that could arise from this instruction.

Identify the expected behavior of the function located in [FILE] at [LINE] that should not have been abstracted. Then, provide a detailed comparison to the actual behavior observed in the last output. Highlight any discrepancies and explain how the abstraction has affected the function's performance or output. Format your response in a clear, structured manner, outlining both the expected and actual behaviors side by side.

Identify the specific rule or constraint that was violated when creating the wrapper function in the context of [PROJECT NAME]. Please quote the exact clause from the relevant documentation or guidelines that indicates this violation should not have occurred. Additionally, provide a brief explanation of why adhering to this constraint is important for the integrity of the code.

Revert the wrapper function in [FILE] at line [LINE] back to a direct implementation of the logic. Please provide the diff output that highlights the changes between the original implementation and the new one. Additionally, explain the reasoning behind reverting to the direct implementation and any potential impacts this change may have on the overall code structure.

Rewrite the function located in [FILE] at line [LINE] to implement it directly without any abstraction. Ensure that the logic is clear and straightforward. Additionally, include a comment in the code that explicitly states this logic should not be abstracted in the future to maintain clarity and simplicity.

Isolate the unnecessary wrapper function in [FILE] at [LINE] and replace it with the original logic. After making this change, please verify that the functionality remains unchanged. Provide a brief summary of the modifications made and any potential impact on the surrounding code.

Identify all functions in [FILE] that are implemented with unnecessary abstraction and are only used once. For each function, explain why it should be implemented directly instead of abstracted. Finally, provide a list of these functions along with recommendations for how to refactor them to eliminate the abstraction.

Identify any dependencies in [FILE] that were introduced by the wrapper function. After analyzing the code, remove any unused imports that are no longer necessary due to the reversion to direct logic. Provide a summary of the changes made, including a list of removed dependencies and any potential impacts on the functionality of the code.

Run the test suite for [FILE] to verify that all functionality remains intact following the removal of the wrapper function. Please provide a detailed report of any failing tests, including the names of the tests that failed and a brief explanation of the reasons for their failure. Additionally, summarize any changes in test coverage as a result of this implementation.

Display the diff of changes made to [FILE] after reverting the wrapper function. Ensure that the output highlights any modified lines clearly. Additionally, provide a brief summary of the changes that were made and confirm whether the modifications were applied correctly.

Replay the original scenario that caused the unnecessary abstraction in [FILE]. Provide a detailed comparison of the output with and without the wrapper, highlighting any discrepancies. Additionally, confirm whether the output matches the expected behavior and explain the implications of the unnecessary abstraction on the overall functionality.

Please verify the edge cases in the code file [FILE] that may have been impacted by the removal of the wrapper function. Identify any potential regressions or new issues that have been introduced as a result of this change. Provide a detailed report outlining each edge case tested, the expected behavior, the actual behavior observed, and any discrepancies found.

Check the state of [FILE] and confirm that it no longer contains any unnecessary abstractions. Provide a detailed list of any remaining functions that still need to be addressed, including a brief description of why each function is considered unnecessary. Additionally, suggest potential improvements or alternatives for each function listed.

Create a system instruction that clearly states: "Do not create wrapper functions for logic that is only used once. Always implement logic directly unless it serves a clear purpose." Ensure this instruction is easily accessible to all developers in the team and consider adding examples of when to avoid unnecessary abstraction versus when it is appropriate. Format this as a guideline document that can be referenced during code reviews.

Please add a comment guard in [FILE] with the following text: 'TODO: Ensure this function is not wrapped unnecessarily. Direct implementation is preferred for single-use logic.' Make sure the comment is placed directly above the function in question, and confirm that it adheres to the project's coding standards.

Draft a project convention message that emphasizes the importance of implementing logic directly for single-use cases. The message should state: "All developers must implement logic directly for single-use cases to maintain code clarity and reduce complexity." Ensure the tone is clear and professional, and include a brief explanation of why this practice is beneficial for the project.

Please create a self-check request that states: 'Before finalizing any function, confirm it is not a wrapper for single-use logic. If it is, revert to direct implementation.' Format this request clearly and concisely, ensuring it emphasizes the importance of avoiding unnecessary abstraction in code.

Please create a guideline for developers that emphasizes the importance of function reuse in coding. The guideline should state: 'Before creating any new function, verify that it will be reused. If it is only used once, implement it directly.' Additionally, provide examples of scenarios where this principle applies and explain the benefits of reducing unnecessary abstraction in code.