All collections (arrays, lists, etc.) are strongly typed and all of them, except for Dictionaries, are instantiated using a collection expression. Classes are strongly typed when instantiated with a constructor. The var keyword is only used in a foreach loop, when using deconstruction or when generating a result with Linq or a method.

Code follows idiomatic functional programming patterns. Ensure functions are pure, and use the pipeline operator (|>) to chain transformations rather than nesting function calls. Avoid unnecessary temporary variables, favor concise expressions, and structure computations in a way that emphasizes data flow. Also prefer pattern matching over if-else unless you're evaluating a boolean statement.

@currentFile - Please check the file for any mistakes. You should look for the following, and be extremely vigilant:
  - Syntax errors
  - Logic errors
  - Security vulnerabilities
  - Performance issues
  - Anything else that looks wrong
Once you find an error, please explain it as clearly as possible, but without using extra words. For example, instead of saying 'I think there is a syntax error on line 5', you should say 'Syntax error on line 5'. Give your answer as one bullet point per mistake found. Wait for follow-up questions before going in-depth with explanations

- Write a comprehensive set of unit tests for the selected code. Make sure that for C# and F# the tests are written using the Xunit library. Setup and run tests that check for correctness including important edge cases, and teardown. Ensure that the tests are complete and sophisticated. - Remind the user you can write the test in a file in agent mode, but give the option to just generate them in the chat window as well.

@currentFile - Add comments but very sparingly, only if the variable names and method names do not clearly express the intent of the code should a single descriptive line comment be added to the selected code.

@currentFile - Add a multi-line comment to all the methods in the current file in the following format: /// <summary> /// /// </summary> /// <param name="id"></param> /// <returns></returns> Describe the functionality inside the summary tags and write a param line for every parameter used in the method and describe the parameter very briefly inside the param tags. Specify the return type.

@currentFile - Conduct a detailed review, evaluating the following:
  - Syntax accuracy
  - Logical consistency
  - Security vulnerabilities
  - Performance inefficiencies
  - Code style adherence
  - Maintainability and readability
  - Potential improvements for modularity and efficiency
  - Error handling and exception management
- Provide clear and structured feedback with actionable improvements - Format responses in a structured list, ensuring readability.

@open - Identify common patterns or functions across files and refactor them into reusable modules or functions. - Point out any potential centralization of code or data. - Provide suggestions for improving code organization and reducing redundancy.

@currentFile - Focus on identifying:
  - Redundant computations
  - Excessive memory allocations
  - Inefficient data structures or algorithms used
  - Unnecessary data transformations or conversions
  - Potential areas for parallelization or concurrency
  - Slow database queries or operations
- Offer alternative solutions and optimizations in a clear and structured manner

@terminal - Analyze the terminal output and identify and errror messages, warnings or failures. - Explain the possible causes concisely. - If you would be able to fix the problem, remind the user that agent mode will allow you to take action - If the fix is not known, suggest possible solutions or next steps for debugging - If dependencies or missing configurations are involved, specify corrective actions.

@currentFile - Review the structure and readability of the code. - Provide suggestions for:
  - Better naming conventions
  - Simplified logic flow
  - More efficient data structures or algorithms
  - More readable error handling or logging
  - Modularization (splitting methods / classes)
  - Separation of concerns (e.g., separating business logic from presentation)
  - Eliminating redundant code
  - Identify primitive obsession