AI Prompts for Simplifying Overengineered Code Suggestions

Please review the following code snippet: [PASTE CODE]. Identify any complex patterns or unnecessary design elements that may complicate the implementation of the intended functionality. Provide a detailed analysis of which design patterns or abstraction layers do not align with the task requirements, explaining why they are excessive and suggesting simpler alternatives. Your response should include specific examples from the code and recommendations for improvement.

Please analyze the following code: [PASTE CODE]. Identify any instances of overengineering and provide specific examples where simpler solutions could be implemented. For each identified area, explain why the current implementation may be considered overengineered and suggest an alternative approach that maintains functionality while reducing complexity. Format your response with clear sections for each instance, including code snippets for the suggested simpler solutions.

Please analyze the following code: [PASTE CODE]. Identify and explain any unnecessary abstraction layers present in the code that do not contribute to the functionality required for the task. For each abstraction you find, provide a brief rationale for why it is deemed unnecessary and suggest a more straightforward approach that could simplify the code while maintaining its intended functionality. Aim for a detailed response that covers at least three specific examples.

Please evaluate the following code for complexity: [PASTE CODE]. Analyze the structure and identify any sections that may be overly complicated or could be simplified while maintaining the same functionality. Provide specific suggestions for refactoring these parts, including examples of how the code could be rewritten for improved clarity and efficiency. Additionally, explain the potential benefits of these simplifications in terms of readability and maintainability.

Examine the following code: [PASTE CODE]. Identify any design patterns that appear to be used unnecessarily and provide a detailed analysis of why they may be considered overengineering. For each identified pattern, suggest simpler alternatives that could achieve the same functionality with less complexity. Additionally, explain the benefits of using the proposed alternatives in terms of maintainability and readability.

Please review the following code: [PASTE CODE]. Identify the abstraction layers present and suggest ways to simplify them for better readability and maintainability. Provide a revised version of the code that eliminates unnecessary complexity while preserving functionality. Additionally, explain the changes made and the reasoning behind simplifying the abstractions, highlighting any improvements in performance or clarity.

Please analyze the following code: [PASTE CODE]. Identify and remove any unnecessary design patterns that complicate the implementation. After simplifying the code, provide a revised version along with a brief explanation of the changes made and why the new implementation is more efficient. Ensure that the final code is clean, easy to understand, and maintains the original functionality.

Please analyze the following code: [PASTE CODE]. Identify any areas of redundancy or unnecessary complexity and suggest improvements to streamline the code. Provide a cleaner, more efficient version of the code with explanations for the changes made. Ensure that the revised code maintains the original functionality while enhancing readability and performance.

Review the following code: [PASTE CODE]. Analyze the logic and identify areas where it can be simplified for better readability and maintainability. Provide a revised version of the code that retains the original functionality but uses clearer and more straightforward constructs. Explain the changes made and why they improve the overall clarity of the code.

Please refactor the following code to simplify its structure while ensuring that its functionality remains intact. The goal is to reduce complexity by eliminating any unnecessary components, improving readability, and enhancing maintainability. Here is the code: [PASTE CODE]. Provide a detailed explanation of the changes made and how they contribute to a simpler design.

Please review the following simplified code: [PASTE CODE]. Assess whether it meets the original requirements and functions correctly. Provide feedback on any potential issues or improvements that could enhance its performance or readability. Additionally, outline the key features that should be tested to ensure it operates as intended.

Please validate the functionality of the following code: [PASTE CODE]. After simplifying the code, confirm that all original features and functionalities are still working as intended. Provide a detailed report on any changes made, including potential impacts on performance or usability. If any issues are found, suggest specific improvements or fixes to restore full functionality.

Please analyze the following code: [PASTE CODE]. Evaluate its simplicity and confirm that it still performs the intended task correctly. Provide a detailed explanation of any changes made to enhance simplicity, and include a comparison of performance metrics before and after the modifications. Additionally, suggest any further improvements that could be made to optimize the code while maintaining its functionality.

Please evaluate the following code for efficiency and performance: [PASTE CODE]. Analyze whether the recent simplifications have maintained or improved the code's execution speed and resource usage. Provide a detailed assessment that includes any potential bottlenecks or areas for improvement, and suggest optimizations if necessary. Additionally, compare the performance metrics before and after the simplification to highlight any significant changes.

Please review the following code: [PASTE CODE]. Assess whether the integrity of the code has been maintained after any simplifications have been made. Provide a detailed analysis that includes identifying any potential issues, explaining how the simplifications may have affected functionality, and suggesting any improvements or corrections needed to ensure the code operates as intended. Your response should be structured in a clear format, highlighting key findings and recommendations.

Create a set of simplicity guidelines for the CLAUDE.md documentation that will help maintain a straightforward and efficient coding style in future projects. The guidelines should cover key principles such as avoiding unnecessary complexity, prioritizing readability, and ensuring that features are implemented in a way that is easy to understand and maintain. Include specific examples of what constitutes simple code versus over-engineered solutions, and suggest best practices for developers to follow. Format the guidelines as a numbered list for clarity and ease of reference.

Please create a detailed simplicity checklist that I can use before accepting any suggestions from Copilot. The checklist should include criteria to evaluate whether the suggestions are overly complex, such as assessing the number of lines of code, the clarity of the logic, the necessity of each component, and the overall maintainability of the solution. Format the checklist as a bulleted list with clear, actionable items that I can easily follow. Additionally, include a brief explanation for each item to clarify its importance in maintaining simplicity in coding.

Please suggest naming conventions that promote simplicity and clarity in code. I would like you to cover various aspects such as variable names, function names, and class names. Provide examples of good naming practices and explain why they are effective. Additionally, format your response as a markdown document titled CLAUDE.md, including sections for each type of naming convention and any relevant guidelines to follow.

Draft a complexity rule for a document titled CLAUDE.md that limits the use of unnecessary design patterns and abstractions in software development. The rule should clearly define what constitutes 'unnecessary' in this context, provide examples of common design patterns that may be overused, and suggest guidelines for when it is appropriate to use abstractions. Additionally, include a rationale for the rule that explains the benefits of simplicity and maintainability in code. Format the rule as a concise statement followed by a brief explanation.

Develop a comprehensive review protocol for assessing suggestions made by Copilot to prevent overengineering in software development. The protocol should include specific criteria for evaluating the relevance and necessity of each suggestion, guidelines for team members on how to provide constructive feedback, and a checklist of common pitfalls to avoid during the review process. Additionally, outline the steps for documenting the review outcomes and any necessary adjustments to the project requirements. Format the protocol as a markdown document titled 'CLAUDE.md' with clear headings and bullet points for easy reference.