AI Prompts for Detecting TypeScript Errors Early

Please analyze the following TypeScript configuration file: [PASTE CONTENT]. Identify any settings that could potentially prevent TypeScript from detecting errors effectively. Provide a detailed explanation of each relevant setting, including its purpose and how it impacts error detection. Additionally, suggest any modifications or best practices to enhance error detection in the configuration.

Please review the following recent changes made to the codebase: [PASTE CHANGES]. Analyze each change to determine if it could potentially impact TypeScript error detection. Provide a detailed explanation for any changes that may have introduced issues, including specific lines of code or configurations that could be relevant. Additionally, suggest any necessary adjustments or further investigations to ensure TypeScript error detection functions correctly.

Analyze the impact of Cascade mode on TypeScript error detection. Specifically, identify any unintended changes or behaviors in this mode that might cause TypeScript errors to be overlooked. Provide examples of scenarios where these issues could arise and suggest potential solutions or best practices to mitigate these risks. Your response should be structured in a clear format, with headings for each section, and aim for a length of at least 200 words.

Please evaluate the following CLAUDE.md file: [PASTE CONTENT]. Analyze the content to identify any specific rules that should have been applied to catch TypeScript errors but were not. Provide a detailed explanation of which rules were missed, why they are important for error detection, and suggest any modifications or additions to ensure better error handling in the future. Format your response as a structured report with clear sections for each identified rule and its implications.

Please review the following autocomplete suggestions: [PASTE SUGGESTIONS]. Analyze each suggestion for potential TypeScript errors that could arise during implementation. Provide a detailed explanation of any issues you identify, including the specific TypeScript rules or principles that may be violated. Additionally, suggest possible corrections or alternatives for any problematic suggestions to ensure compatibility with TypeScript standards.

Review the current settings in the tsconfig.json file and provide detailed recommendations for adjustments that will enhance TypeScript error detection. Include specific configuration options that should be enabled or modified, such as strict mode settings, compiler options, and any relevant paths or includes that may affect error reporting. Additionally, explain how each suggested change will improve the detection of TypeScript errors and the overall development experience. Format your response as a clear list of changes with explanations for each.

Please help me enhance TypeScript error detection by modifying the CLAUDE.md rules. I need a detailed list of the specific changes that should be made, including any new rules to add or existing rules to adjust. Additionally, explain the rationale behind each change and how it will improve error detection. Format your response as a clear step-by-step guide that I can follow to implement these modifications.

Please provide a detailed plan to refine the autocomplete settings in order to minimize suggestions that may lead to TypeScript errors. Include specific adjustments that can be made to the configuration, such as changing the sensitivity of the autocomplete feature, setting up type checking options, and any relevant best practices for ensuring that the suggestions align with TypeScript's type system. Additionally, outline how to test these adjustments to confirm that they effectively reduce the occurrence of erroneous suggestions.

Please provide a detailed list of specific changes that can be made in Cascade mode to ensure that TypeScript errors are not overlooked. Include adjustments related to configuration settings, code review practices, and any relevant tools or features that can enhance error detection. Additionally, explain how these changes can improve overall code quality and developer efficiency. Format your response as a structured guide with clear steps and examples where applicable.

Identify the recent changes made in the codebase that may be causing TypeScript errors to go undetected. Provide a detailed analysis of each change, explaining how it could affect TypeScript's error detection. Suggest specific fixes or adjustments to ensure that all TypeScript errors are properly identified moving forward. Format your response as a step-by-step guide, including code snippets where applicable, and highlight any best practices to prevent similar issues in the future.

Please perform a comprehensive TypeScript check on the project located at [PROJECT_PATH]. Identify and report any errors or warnings that are present in the codebase. For each error, provide a brief description of the issue, its location in the code, and suggestions for how to resolve it. Additionally, summarize any potential impacts these errors may have on the functionality of the project.

Please verify that the updated CLAUDE.md rules are effectively detecting TypeScript errors. Provide a detailed report on the current performance of the rules, including any specific errors that are being detected and those that are still not recognized. Additionally, outline any discrepancies between the expected behavior and the actual results observed during testing. If there are still issues, suggest potential adjustments or improvements to enhance the error detection capabilities.

Please verify the functionality of the autocomplete feature by testing it with various code snippets that previously triggered TypeScript errors. Provide a detailed report on whether the autocomplete suggestions now exclude any code containing these errors. Include examples of the code snippets used, the expected behavior, and the actual behavior observed during testing. Additionally, summarize any improvements or remaining issues related to the autocomplete feature's performance.

Please analyze the recent changes made in Cascade mode to ensure that no TypeScript errors have been introduced. Provide a detailed summary of any modifications, highlighting specific areas where potential issues may arise. Additionally, check for any inconsistencies or discrepancies in the code that could lead to errors. Include recommendations for resolving any identified issues and confirm that the overall functionality remains intact.

Please confirm whether the recent fixes have successfully resolved the TypeScript error detection issue. Provide a detailed analysis of the current state of error detection, including any remaining issues or improvements observed since the fixes were implemented. Additionally, outline the steps taken to verify the resolution and any relevant metrics or examples that demonstrate the effectiveness of the fixes. Conclude with recommendations for further actions if necessary.

Please create a new rule for CLAUDE.md that addresses recent TypeScript errors encountered in the project. The rule should outline specific coding practices or guidelines that developers should follow to avoid these errors in the future. Include examples of common mistakes that lead to these issues and suggest best practices for writing TypeScript code. Additionally, provide a brief explanation of why each guideline is important for maintaining code quality and preventing errors.

Create a comprehensive guideline for using autocomplete features effectively in TypeScript to minimize the introduction of errors. Include best practices for setting up the development environment, tips for selecting appropriate types, and strategies for reviewing autocomplete suggestions before accepting them. Additionally, cover common pitfalls that developers may encounter and how to avoid them, as well as examples of correct and incorrect usage. Format the guideline as a structured document with clear headings and bullet points for easy reference.

Create a detailed protocol for implementing Cascade mode in a TypeScript project to minimize the risk of errors. The protocol should include specific steps for setting up the environment, guidelines for writing TypeScript code that is compatible with Cascade mode, and best practices for testing and debugging. Additionally, outline common pitfalls to avoid and provide examples of how to handle potential issues that may arise during development. Format the protocol as a comprehensive guide that can be easily referenced by developers.

Please add a code comment in the critical areas of the codebase that serves as a reminder for developers to check for TypeScript errors. The comment should be clear and concise, explaining the importance of verifying TypeScript errors before proceeding with further development. Additionally, specify any common pitfalls or examples of TypeScript errors that developers should be particularly mindful of. Ensure the comment is placed in a way that it is easily visible and can be referenced quickly during the coding process.

Please develop a comprehensive pre-commit checklist that outlines specific steps to ensure TypeScript error detection is functioning correctly before code is committed. Include items such as running TypeScript compilation checks, verifying linting rules are followed, and ensuring all tests pass. Additionally, suggest best practices for maintaining code quality and preventing errors from being introduced into the codebase. Format the checklist in a clear, actionable way that can be easily followed by developers.