AI Prompts for Simplifying Overengineered Features

Analyze the current implementation of [TASK DESCRIPTION] in detail. Identify and highlight any abstraction layers or design patterns that do not contribute to the essential functionality of the task. For each unnecessary abstraction, explain why it is not needed and suggest a more straightforward approach that could simplify the implementation. Additionally, provide examples of how removing these abstractions could improve code readability and maintainability. Aim for a comprehensive analysis that covers all relevant aspects.

Review the provided code and identify any design patterns that have been applied. For each design pattern, explain its purpose and relevance to the current task, detailing why it is necessary or unnecessary in this context. Additionally, provide suggestions for alternative approaches if the patterns used are deemed inappropriate, and discuss the potential impact of these choices on the code's maintainability and scalability. Format your response in a structured manner, with each design pattern clearly labeled and analyzed.

Evaluate the complexity of the current solution for [TASK DESCRIPTION]. Analyze the code structure and identify specific areas where simplification is possible while maintaining full functionality. Provide detailed recommendations on how to refactor these components, including examples of simpler alternatives and the potential benefits of these changes. Additionally, consider the impact of the current complexity on performance and maintainability, and suggest best practices for future development to avoid overengineering.

Please analyze the current implementation of the code and provide a comprehensive list of all dependencies that have been introduced. For each dependency, indicate whether it is necessary for the task at hand or if it can be considered extraneous. Additionally, provide a brief explanation for each dependency's relevance or lack thereof, and suggest any potential simplifications that could be made to streamline the code without losing functionality.

Please review the contents of my CLAUDE.md file, which I will provide below: [PASTE CONTENT]. Assess whether the current implementation adheres to the principles of simplicity and minimalism as outlined in the guidelines. Specifically, identify any areas where the implementation may be overly complex or diverges from the intended rules. Provide a detailed analysis of your findings, including suggestions for improvement to enhance compliance with these principles.

Identify and analyze the current abstraction layers in the implementation of [TASK DESCRIPTION]. Determine which layers do not contribute to the core functionality and can be safely removed without affecting the overall performance or usability. Provide a detailed explanation of each identified abstraction, including its purpose and the impact of its removal. Finally, suggest any necessary adjustments to ensure the core functionality remains intact after the removal of these abstractions.

Refactor the provided code to simplify the design patterns used, focusing on eliminating any unnecessary complexity. Ensure that the resulting code remains functional and efficient while maintaining the original functionality. Additionally, explain the changes made and the reasoning behind simplifying each design pattern. Provide a summary of the benefits of the refactored code in terms of readability, maintainability, and performance.

Please analyze the following code and identify areas where complexity can be reduced. Focus on simplifying the complex parts to enhance readability and maintainability. Provide specific suggestions for refactoring, including any code snippets that illustrate the improvements. Additionally, explain the rationale behind each change and how it contributes to better code quality.

Analyze the codebase for [TASK DESCRIPTION] and identify any dependencies that are not essential for its functionality. Create a list of these redundant dependencies and provide a brief explanation for each one on why it can be removed. After identifying the dependencies, modify the code to eliminate them while ensuring that the code still runs correctly and passes all tests. Finally, document the changes made and any potential impacts on the overall project.

Please review the current implementation and identify areas where it can be simplified according to the rules outlined in the CLAUDE.md file. For each modification made, provide a brief explanation of how it aligns with the simplicity guidelines. Additionally, summarize the overall impact of these changes on the functionality and maintainability of the code. Ensure that the final implementation remains effective while adhering to the principles of simplicity.

Run the relevant tests to confirm that the simplified solution for [TASK DESCRIPTION] meets all functional requirements. Provide a detailed report of the test results, including any discrepancies found, the expected outcomes versus the actual outcomes, and any recommendations for further adjustments if necessary. Additionally, summarize the overall functionality and performance of the solution after simplification, highlighting any areas that may need further attention.

Compare the complexity of the original implementation and the simplified version of the feature. Provide a detailed analysis that includes a breakdown of the code structure, the number of lines, and the overall readability of both implementations. Confirm whether the new version is indeed simpler and more efficient by discussing specific improvements in performance and maintainability. Include examples to illustrate the differences in complexity and efficiency between the two versions.

Please validate the removal of specific dependencies from the project. Re-run the project without the following dependencies: [LIST OF DEPENDENCIES]. Confirm that the project still functions correctly by providing a detailed output of the execution, including any errors or warnings encountered during the process. Additionally, summarize any changes in performance or functionality observed after the removal of these dependencies.

Please verify that the current implementation adheres to the rules outlined in CLAUDE.md. Identify and highlight any discrepancies or areas where compliance is lacking. Provide a detailed report that includes specific sections of CLAUDE.md that are not being met, along with suggestions for how to address these issues. Ensure that the report is structured clearly, making it easy to understand the compliance status and necessary improvements.

Please execute a series of tests to identify and evaluate edge cases for the simplified solution. Focus on scenarios that may not be typical but could potentially cause failures or unexpected behavior. Document the results of each test, including the input used, the expected outcome, and the actual outcome. Additionally, provide an analysis of any failures and suggest improvements to enhance the robustness of the solution.

Please draft a new rule for the CLAUDE.md file that emphasizes the importance of simplicity and minimalism in solutions. The rule should clearly articulate why simplicity is vital in design and implementation, and it should provide specific guidelines on how to achieve minimalism in features. Include examples of overly complex solutions and how they could be simplified. The final text should be concise, ideally no more than five sentences, and formatted for easy inclusion in the existing document.

Please write a code comment to be placed above the function [FUNCTION_NAME] that warns against unnecessary complexity. The comment should clearly state the importance of keeping the function simple and easy to understand, and it should encourage future developers to avoid overengineering features. Make sure the comment is concise, yet informative, ideally no more than three sentences long. Provide the exact text of the comment that can be directly inserted into the code.

Help me develop a simplification checklist that can be used at the start of any project session to ensure that solutions remain straightforward and effective. The checklist should include specific criteria to evaluate proposed features, such as: is the feature necessary, does it solve a clear problem, can it be implemented with minimal complexity, and how will it enhance user experience? Format the checklist in a clear, bulleted list and aim for at least 8 to 10 items that can guide decision-making throughout the project.

Please define a project convention that emphasizes simplicity in code design. Include specific guidelines that should be followed to ensure that features are implemented in a straightforward manner, avoiding unnecessary complexity. The convention should cover aspects such as naming conventions, code structure, documentation practices, and examples of simple versus over-engineered solutions. Format your response as a clear and concise document that can be easily referenced by the development team.

Create a session opener that emphasizes the importance of simplicity and avoiding overengineering when beginning a new task. The opener should include a brief introduction that sets a positive tone, a reminder of the benefits of keeping things simple, and a motivational statement to encourage focus on essential features. Aim for a length of 3-5 sentences that can be easily read aloud at the start of a meeting or work session.