AI Prompts for Updating Function Signatures Safely

Please identify all function signatures or module exports that have been modified recently in the codebase. For each modified signature, provide both the previous and current forms, along with a brief explanation of the changes made. Additionally, categorize the changes based on their impact, such as breaking changes or enhancements. Format the output in a clear table with columns for the signature name, previous form, current form, and change description.

Please search the entire project for all instances where the function [FUNCTION_NAME] is called or the module [MODULE_NAME] is imported. For each instance found, provide the file paths and line numbers where these occurrences take place. Additionally, summarize the context in which the function or module is used, including any relevant comments or documentation that may help in understanding its purpose within the codebase.

Scan the project for any unresolved references or import errors related to [FUNCTION_NAME] or [MODULE_NAME]. Identify and list all instances where these references are not properly defined or imported. For each issue, provide a brief description of the problem, including the file name and line number where the error occurs. Additionally, suggest possible solutions or steps to resolve these issues to ensure the project compiles and runs correctly.

Please review the recent commit history for the project and highlight any changes that are related to function signatures or module exports. Specifically, focus on the changes made to [FUNCTION_NAME] or [MODULE_NAME]. For each change, provide a brief summary of what was altered, the implications of these changes on the overall functionality, and any potential impact on existing code or dependencies. Format the output as a detailed report with bullet points for clarity.

Please analyze the latest error logs for issues related to [FUNCTION_NAME] or [MODULE_NAME]. Identify and summarize the relevant errors, including their frequency, potential causes, and any patterns that may indicate underlying problems. Provide recommendations for resolving these issues and improving system stability. Format the findings in a clear report that highlights the most critical errors and suggested next steps for troubleshooting.

Please review all instances of the function [FUNCTION_NAME] in my codebase and update each call to match the new signature. For each file where changes are made, provide a summary of the modifications, including the original and updated function call formats. Additionally, confirm that the updated calls maintain the intended functionality and do not introduce any errors. Finally, list any files that were not modified and explain why no changes were necessary.

Please modify all import statements for the module [MODULE_NAME] to align with the updated export structure. Ensure that you check all relevant files in the project and provide a detailed list of each file that has been modified. Additionally, include a brief explanation of the changes made to the import statements and any potential impacts on the functionality of the module. Format the output as a summary report that can be easily reviewed.

Refactor the code that depends on [FUNCTION_NAME] or [MODULE_NAME] to ensure it is compatible with the recent changes made. Identify all instances where this code is utilized and analyze how the changes affect its functionality. Provide a detailed explanation of the modifications made, including any new dependencies introduced, and ensure that the refactored code maintains the same performance and reliability standards as before. Include comments in the code to clarify the purpose of each change and any potential impacts on other parts of the system.

Identify any deprecated usage patterns of [FUNCTION_NAME] or [MODULE_NAME] in the codebase. Provide a detailed report that includes specific instances where deprecated features are used, along with explanations of why they are considered deprecated. For each deprecated usage, suggest modern alternatives that can be implemented, including code examples and any necessary adjustments to ensure compatibility with the latest standards. Additionally, outline the potential impact of these changes on the overall functionality and performance of the application.

Please update the project documentation to accurately reflect the recent changes made in [FUNCTION_NAME] or [MODULE_NAME]. Include a detailed summary of the updates, specifying what modifications were made, the reasons behind these changes, and any implications for users or developers. Ensure that the documentation is clear, concise, and organized in a way that highlights the most critical updates first. Format the summary in bullet points for easy readability and include any relevant examples or code snippets that illustrate the changes.

Please execute all unit tests related to [FUNCTION_NAME] or [MODULE_NAME]. After running the tests, provide a detailed report that includes the number of tests executed, the number of tests that passed, and any failures encountered. For each failure, include the specific error message and the line of code where the failure occurred. Additionally, summarize any patterns or common issues observed in the test results.

Please perform integration tests to verify that the [FUNCTION_NAME] or [MODULE_NAME] interacts correctly with other components of the system. Outline the specific scenarios you will test, including expected inputs and outputs for each integration point. Additionally, provide a summary of any issues encountered during testing and recommendations for resolving them. The final report should be structured with clear headings for each test case, detailing the test steps, results, and any necessary follow-up actions.

Please review the application logs for any errors or warnings that have arisen following the recent changes made in [FUNCTION_NAME] or [MODULE_NAME]. Focus on identifying specific issues that may have impacted functionality or performance. Summarize the findings in a report, detailing the type of errors or warnings found, their frequency, and any patterns observed. Additionally, provide recommendations for addressing these issues to ensure smooth operation moving forward.

Please simulate user interactions for the [MODULE_NAME] and validate that the user interface behaves as expected. Focus on key functionalities such as [LIST KEY FUNCTIONALITIES] and ensure that all elements respond correctly to user inputs. Document any discrepancies you find, including specific steps to reproduce the issue and the expected versus actual outcomes. Provide a summary of your findings in a structured format, highlighting any areas that require further attention or improvement.

Please verify the stability of the API endpoints associated with [FUNCTION_NAME] or [MODULE_NAME]. Conduct tests to ensure that each endpoint returns the expected results, including status codes, response times, and data formats. Document any discrepancies or errors encountered during testing, and provide a summary of the overall stability of the API, including any recommendations for improvements if issues are found. Include specific details about the endpoints tested and the expected versus actual outcomes.

Draft a new rule for CLAUDE.md that mandates the tracking and updating of all function signature changes. This rule should outline the specific procedures for documenting changes, including who is responsible for making updates, how changes should be communicated to the team, and the timeline for implementing these updates. Additionally, include examples of proper documentation practices and any tools or methods that should be used to ensure compliance with this rule. The final document should be clear, concise, and structured in a way that is easy for all team members to follow.

Please add detailed comments throughout the codebase that explain the significance of maintaining function signature consistency. Focus on how consistent function signatures contribute to code readability, maintainability, and reduce the likelihood of errors during development. Include examples of potential issues that can arise from inconsistent signatures and suggest best practices for ensuring consistency. The comments should be clear and informative, making it easy for future developers to understand the rationale behind this coding standard.

Please propose a detailed naming convention for functions and modules that allows for easy identification of their versions and changes. The convention should include guidelines on how to incorporate version numbers, such as major, minor, and patch updates, into the names. Additionally, outline how to indicate deprecated functions or modules, and suggest best practices for maintaining consistency across a codebase. Provide examples of naming conventions that could be applied in a programming context, ensuring that they are clear and easy to follow.

Develop a comprehensive checklist for developers to use when modifying function signatures or module exports in their code. The checklist should include key considerations such as ensuring backward compatibility, updating documentation, testing for potential breaking changes, and communicating changes to the team. Additionally, include steps for reviewing code changes and verifying that all dependent modules are updated accordingly. Format the checklist in a clear, organized manner with bullet points for easy reference.

Propose a project guard mechanism that can automatically detect and alert on breaking changes in function signatures within a software project. Include details on how this mechanism would work, what specific criteria it would use to identify breaking changes, and how alerts would be communicated to the development team. Additionally, outline any best practices for implementing this guard in a way that minimizes disruption to the development workflow and ensures timely updates. Provide examples of scenarios where this mechanism would be particularly beneficial.