AI Prompts for Simplify Overengineered Features

Please quote the exact output from the last build that indicates unnecessary complexity. Focus specifically on identifying the function or component that deviates from the original requirements. Provide a detailed explanation of how this complexity impacts the overall functionality and suggest potential simplifications that could align it more closely with the initial specifications.

Please analyze the following build output from the last run: [BUILD OUTPUT]. Identify any sections that demonstrate excessive abstraction or design patterns that deviate from the original task. Provide a detailed explanation of each identified issue, including why it is considered over-engineered and suggest potential simplifications or alternatives that align more closely with the initial requirements.

Please interpret the following instruction regarding feature implementation: [LAST INSTRUCTION]. Clearly outline your understanding of the key points and any specific actions you believe are required. Additionally, identify any potential areas of confusion or miscommunication that may need further clarification. Provide your response in a structured format that highlights your interpretation and any questions you may have.

Compare the expected behavior to the actual behavior of the last implemented feature, which is [FEATURE NAME]. Clearly outline the expected outcome, detailing the specific criteria that define success. Then, describe the actual behavior observed, highlighting any discrepancies or issues encountered. Finally, provide a brief analysis of the potential reasons for these differences and suggest possible improvements or adjustments to align the actual behavior with the expected outcome.

Identify the specific design pattern or abstraction layer that was violated in the last implementation of [PROJECT NAME]. Please provide the exact clause or rule from the design documentation that was not adhered to, and explain how this violation impacts the overall system architecture. Additionally, suggest potential remedies to address this violation and prevent similar issues in the future.

Please revert the function at [FILE]:[LINE] to its original implementation, which is as follows: [PASTE]. Ensure that no other parts of the code are altered in this process. Provide a brief explanation of why the original functionality is preferred over the current overengineered version.

Rewrite the component located at [FILE] on line [LINE] to eliminate unnecessary abstraction layers. Ensure that the revised version is straightforward and functional, adhering closely to the original requirements. Provide a brief explanation of the changes made and how they improve the component's clarity and performance.

Please analyze the function located at [FILE]:[LINE] and identify any unnecessary design patterns that can be removed to simplify the logic. Provide a revised version of the function that maintains its core functionality while streamlining the code. Additionally, explain the changes made and why they contribute to a simpler design.

Enforce a minimalist design approach in the component located at [FILE]:[LINE]. Identify and list all current features implemented in this component, then evaluate each feature to determine if it is essential. Provide recommendations for removing any non-essential features and outline how to simplify the remaining features to reduce complexity while maintaining functionality.

Please review the imports in [FILE] and identify any dependencies that are not necessary for the current functionality. For each unnecessary import, provide a brief explanation of why it can be removed and suggest a simplified import structure that maintains the required functionality. Present your findings in a clear list format, detailing the original imports and the recommended changes.

Please run a test on the simplified component located at [FILE]. Confirm that it behaves as expected by checking its functionality against the requirements. Provide a summary of the test results, including any issues encountered and suggestions for further simplification if necessary.

Please provide a detailed diff of the changes made to [FILE]. Highlight the specific areas where overengineering has been removed and explain how the functionality has been preserved. Additionally, summarize any potential impacts of these changes on overall performance or user experience.

Replay the scenario that previously failed due to overengineering. Confirm whether the simplified implementation resolves the issues by providing a detailed analysis of what was changed and how it affects the overall functionality. Include specific examples of the previous failures and the current outcomes to illustrate the improvements made.

Please analyze the simplified function located at [FILE] for potential edge cases. Identify any inputs that may lead to unexpected behavior and explain how the function handles these scenarios. Provide a summary of your findings, including any recommendations for improving the function's robustness while maintaining simplicity.

Please confirm the output state of the component located at [FILE]. Analyze the current output and compare it to the expected behavior following the simplification process. Provide a detailed report outlining any discrepancies, including specific examples of where the output does not align with expectations, and suggest potential adjustments to rectify these issues.

Create a session-opening constraint for the project titled [PROJECT NAME]. The constraint should state: 'Before implementing any feature, verify that it does not introduce unnecessary complexity. If complexity is detected, stop and simplify before continuing.' Ensure that the wording is clear and actionable for the team to follow during the development process.

Please draft a project specification message for the implementation of new features. The message should emphasize the importance of simplicity in feature design. Include a section where you list any necessary abstractions and provide a justification for each one, explaining why they are essential for maintaining simplicity. Ensure that the final output is clear and structured for easy reference by the development team.

Create a naming convention guideline for software components that emphasizes simplicity and clarity. The guideline should state: "All components must be named to reflect their functionality clearly without implying added complexity. Use names that indicate straightforward behavior." Additionally, provide examples of good and bad naming practices, and explain why clear naming is essential for maintainability and collaboration within the development team. Format this as a concise document that can be easily referenced by team members.

Please create a self-check request for an agent that includes the following instructions: Before finalizing any feature, assess whether it adheres to the simplicity guideline. If the feature does not meet this guideline, generate a detailed report outlining the complexity introduced, including specific examples of how it deviates from simplicity and suggestions for simplification. Format the report to include sections for the feature description, complexity factors, and recommendations.

Create a system prompt that emphasizes the importance of using only essential design patterns for feature functionality. The prompt should state: 'Only use design patterns that are essential for the functionality of the feature. If a pattern is not necessary, remove it before implementation.' Additionally, provide a brief explanation of why minimizing design patterns can lead to simpler, more maintainable code.