AI Prompts for Preventing Function Signature Mismatches

Identify all functions in the current file that have had their signatures changed. For each modified function, provide the original signature as well as the new signature. Additionally, include a brief explanation of how the changes may affect the functionality of the code. Format the output as a table with columns for the function name, original signature, new signature, and impact description.

Please identify all files in the codebase that call the function [FUNCTION_NAME]. For each file, provide a brief description of how the function is used and any potential impact the signature change may have on the functionality of the application. Additionally, include the line numbers where the function calls occur and suggest any necessary modifications that may be required to accommodate the signature change.

Please analyze the current file and identify all module exports that have been modified. For each changed export, provide the new export statement along with a brief explanation of the change made. Additionally, include the original export statement for comparison. Format the results in a clear list, highlighting any significant differences or implications of these changes on the overall module functionality.

Please scan the open files in the current project for any calls to [FUNCTION_NAME] that do not conform to its updated signature. For each mismatched call, provide the line number where it occurs and suggest specific fixes to align it with the new signature. Additionally, summarize the potential impact of these broken calls on the overall functionality of the application and any necessary steps to ensure compatibility moving forward.

Please review the import statements in the currently open files of my project. Identify any that may be broken due to recent changes in module exports and provide suggestions for corrections. Include details on which specific modules are affected and explain the nature of the changes that led to the breakage. Format your response as a list, clearly indicating the original import statement, the suggested correction, and a brief rationale for each change.

Identify all instances where the function [FUNCTION_NAME] is called in the codebase and analyze each call to determine how it has broken due to changes in its signature. For each broken call, provide a detailed suggestion for the correct call format, including any required parameters and their types. Additionally, explain the changes made to the function signature that necessitate these updates, and ensure that the suggested calls adhere to best practices for code readability and maintainability. Present your findings in a clear, organized format that can be easily referenced during the update process.

Identify all affected files that require updated import statements due to changes in module exports. For each file, provide a list of the current import statements along with the corrected versions that align with the new module structure. Ensure that the corrected statements are formatted correctly for the programming language being used and include any necessary adjustments to paths or module names. Present the corrections in a clear, organized manner that allows for easy implementation.

Identify the code blocks in my project that rely on the old function signature of [FUNCTION_NAME]. For each affected code block, provide detailed suggestions for refactoring to accommodate the new function signature. Include explanations for why each suggested change improves the code, and ensure that the refactored code maintains the same functionality as before. Present your suggestions in a clear format, highlighting the original code alongside the refactored version for easy comparison.

Review the module exports across the entire project to ensure consistency. Identify any discrepancies in the export statements, including missing or incorrectly named exports. For each discrepancy found, provide a detailed explanation of the issue and suggest specific fixes to align the exports correctly. Format the findings in a clear list, including the file names and the exact lines where the discrepancies occur, along with the proposed corrections.

Please update all occurrences of [FUNCTION_NAME] in the currently open files to reflect its new signature. Ensure that the changes are consistent throughout the codebase and check for any potential issues that may arise from this update. After making the changes, provide a summary of the modifications made, including the number of occurrences updated and any lines of code that were affected. Additionally, verify that the updated function signature is correctly implemented in all relevant contexts.

Please conduct a thorough code check to verify that all function calls and imports in my project are correct. Analyze the code for any discrepancies or errors, and provide a detailed report of any remaining issues you find. Include specific line numbers and descriptions of the problems, as well as suggestions for how to resolve them. Ensure that the report is clear and organized for easy reference.

Please verify that all updated function calls to [FUNCTION_NAME] are executing without errors. Provide a detailed report that includes the following: a list of each function call tested, the expected outcome for each call, the actual outcome observed, and any error messages encountered during execution. Additionally, summarize any discrepancies between expected and actual outcomes, and suggest potential fixes or improvements if errors are found.

Please validate that all module exports in the files are correctly recognized in the corresponding import statements. Identify any discrepancies or errors in the import/export relationships and provide a detailed report of your findings. Include the names of the modules, the specific files where the errors occur, and suggestions for correcting any issues you discover. Ensure that the report is clear and structured for easy understanding.

Please run comprehensive tests on the modules affected by the recent changes in the codebase. Identify which specific modules have been impacted and outline the key functionalities that need to be verified. For each module, provide a summary of the tests conducted, the expected outcomes, and the actual results. Additionally, highlight any issues or discrepancies found during testing and suggest potential fixes or areas for further investigation.

Please scan the codebase for any new errors that may have been introduced by the recent changes. Identify and categorize the issues based on their severity, such as critical, major, or minor. For each error found, provide a brief description, the location in the code where it occurs, and any relevant suggestions for resolution. Format the output as a structured report that can be easily reviewed.

Draft a new rule for CLAUDE.md that ensures function signatures are consistently updated across all files in the repository. The rule should outline the specific format and structure that function signatures must follow, including naming conventions, parameter types, and return types. Additionally, include guidelines for versioning and documentation updates whenever a function signature is modified. Provide examples of both compliant and non-compliant function signatures to illustrate the expectations clearly.

Please insert a detailed comment in the codebase that explains the importance of updating all function calls whenever a function signature changes. The comment should clarify how failing to do so can lead to runtime errors, unexpected behavior, or broken functionality in the application. Additionally, emphasize the potential impact on maintainability and collaboration within the development team. Ensure the comment is clear, concise, and positioned appropriately within the code for maximum visibility.

Please suggest a comprehensive naming convention for functions that minimizes the risk of signature mismatches in API contracts. The convention should include guidelines on how to structure function names, what prefixes or suffixes to use, and any specific patterns that should be followed to ensure clarity and consistency. Additionally, provide examples of well-named functions that adhere to this convention and explain how they help prevent signature mismatches. Aim for a detailed explanation that can serve as a reference for developers.

Please create a comprehensive checklist for developers to follow when modifying function signatures or module exports. The checklist should include key considerations such as: ensuring backward compatibility, updating relevant documentation, running existing tests to confirm no breakage occurs, communicating changes to the team, and reviewing code for potential impacts on dependent modules. Format the checklist in a clear, numbered list and provide brief explanations for each item to ensure understanding of its importance.

Design a project guard mechanism that automatically identifies and flags mismatches in function signatures during the development process. The guard should analyze the codebase for any discrepancies between the defined function signatures and their implementations, providing real-time alerts to developers. Include details on how the mechanism will integrate with existing development workflows, the types of mismatches it will detect (e.g., parameter types, return types), and the format of the alerts. Additionally, outline any configuration options available to customize the sensitivity of the guard and how it can be tested for effectiveness.