AI Prompts for Eliminating Unnecessary Abstractions

Please analyze the current project and provide a comprehensive list of all wrapper functions present. For each wrapper function, indicate whether it is utilized more than once or if it is only called a single time. Additionally, include a brief explanation of the purpose of each wrapper function and how it contributes to the overall functionality of the project. Format the results in a table with columns for the function name, usage frequency, and description.

Identify and analyze the utility layers within the project. Highlight each layer that encapsulates logic used in a single location, providing a brief description of its purpose and functionality. Additionally, explain how these utility layers contribute to the overall architecture of the project and any potential benefits they offer in terms of code maintainability and reusability. Present your findings in a structured format, including a list of the identified layers and their respective descriptions.

Identify all higher-order components in the codebase and analyze their usage. For each higher-order component, specify which components they are applied to and highlight any that are only applied to a single component. Additionally, provide insights on whether these higher-order components could be refactored or reused more effectively across multiple components. Summarize your findings in a report format, including recommendations for improving component reusability and maintainability.

Please analyze the codebase and generate a report detailing the functions that are wrapped or abstracted but utilized in only one location. For each function, include the function name, the specific location where it is used, and a brief explanation of its purpose. Additionally, assess whether these functions should be refactored for better clarity and efficiency, and provide recommendations on how to simplify the code if necessary. Format the report with clear headings and bullet points for easy readability.

Please generate a comprehensive list of all abstractions that are used only once within the project. For each abstraction, include a brief description of its purpose and functionality, as well as the specific context in which it is applied. Additionally, categorize these abstractions based on their type, such as data structures, functions, or classes. Aim for clarity and detail to ensure that the list serves as a useful reference for understanding the project's architecture.

Identify all wrapper functions in the codebase that are used only once. For each of these functions, integrate their logic directly into the places where they are called. Ensure that the resulting code maintains readability and functionality, and document any changes made for future reference. Provide a summary of the changes, including the names of the removed functions and the locations in the code where their logic was integrated.

Refactor the code to simplify utility layers that are used only once. Identify any utility layers that are unnecessary and replace them with the logic they encapsulate. Ensure that the code remains clean and maintainable after the refactoring process. Provide a summary of the changes made and explain how this simplifies the overall code structure.

Refactor the higher-order components that currently wrap a single component in my codebase. The goal is to simplify the code structure while maintaining the same functionality. Please provide a step-by-step guide on how to achieve this, including specific examples of the changes to be made. Additionally, outline any potential benefits of this refactoring in terms of readability and maintainability of the code.

Identify instances in my code where single-use functions are defined inline but abstracted unnecessarily. Provide specific examples of these functions and suggest ways to simplify the code by either inlining the function logic directly or removing the abstraction. Explain the benefits of reducing complexity in this context, and how it can improve readability and maintainability of the code. Additionally, provide recommendations for best practices when deciding whether to abstract a function or not.

Identify any instances of redundant logic in the code that have been abstracted unnecessarily. Explain why this abstraction may be problematic and provide specific examples from the code. Additionally, suggest ways to simplify the logic while maintaining functionality, and outline the benefits of consolidating these redundancies for overall code clarity and performance.

Please confirm that all single-use wrapper functions have been successfully removed from the codebase. Provide a detailed report outlining the specific functions that were eliminated, along with an explanation of how their logic has been integrated into the main code. Additionally, include any potential impacts on performance or readability resulting from this change, and suggest any further improvements that could enhance the overall structure of the code.

Identify any utility layers in the code that are used only once and provide a detailed explanation of how they can be simplified or removed. For each utility layer, include the specific location in the code, the purpose it served, and the impact of its removal on the overall functionality. Additionally, suggest alternative approaches or refactorings that could achieve the same outcome without the need for these utility layers. Format your response as a structured report with clear sections for each utility layer analyzed.

Please validate whether the higher-order components that are currently wrapping a single component have been successfully refactored. Provide a detailed analysis of the changes made, including the specific components involved, the reasons for the refactoring, and any improvements in code readability or performance. Additionally, outline any potential issues that may arise from this refactoring and suggest best practices for future component architecture. Format your response as a structured report with clear sections for each aspect discussed.

Please review the code changes to ensure that all single-use functions have been inlined appropriately. Identify any unnecessary abstractions that have been removed and confirm that the code maintains clarity and functionality after these changes. Provide a summary of your findings, including any specific lines of code that were modified, and suggest improvements if any single-use functions remain or if further simplifications can be made.

Evaluate the overall complexity of the following code after removing unnecessary abstractions. Please analyze the code for factors such as readability, maintainability, and performance. Provide a detailed assessment that includes specific examples of how the complexity has changed, any potential areas for further improvement, and suggestions for best practices to maintain low complexity in future code. Format your response in a structured manner with clear headings for each section.

Please draft a CLAUDE.md rule aimed at preventing the creation of single-use abstractions in our codebase. The rule should clearly define what constitutes a single-use abstraction and provide guidelines on how to identify and avoid them during the development process. Include examples of common pitfalls and suggest best practices for creating reusable components instead. Additionally, outline the potential impacts of single-use abstractions on code maintainability and team collaboration.

Create a comprehensive set of code comment guidelines aimed at discouraging unnecessary abstraction in programming. The guidelines should cover the importance of clarity and simplicity in code, emphasizing when abstraction is beneficial and when it may lead to confusion. Include specific examples of good and bad abstraction practices, and suggest best practices for writing comments that enhance code readability and maintainability. Format the guidelines in a clear, structured manner with bullet points for easy reference.

Please create a comprehensive checklist to review potential abstractions at the start of each coding session. The checklist should include items such as assessing the current project requirements, identifying areas where abstraction could improve code readability and maintainability, evaluating the trade-offs of introducing abstractions, and ensuring alignment with overall project goals. Additionally, include a section for documenting any decisions made regarding abstractions and their justifications. Format the checklist in a clear and organized manner, with bullet points for easy reference.

Propose a set of naming conventions that clearly indicate single-use abstractions within a codebase. The conventions should include guidelines for naming variables, functions, and classes, ensuring that they are descriptive and easy to understand at a glance. Provide examples of effective naming patterns and explain how these conventions can improve code readability and maintainability. Additionally, outline any potential pitfalls to avoid when establishing these conventions.

Create a project guard that identifies and flags potential unnecessary abstractions during code reviews. This guard should analyze code for complexity and suggest simplifications where appropriate. Include criteria for what constitutes an unnecessary abstraction, such as over-engineering or excessive layering. Provide a report format that summarizes the findings and recommendations for each flagged instance, ensuring that it is easy for developers to understand and act upon the suggestions.