Cursor rules for code development with guidelines integration

When to use this skill

Cursor rules for code development with guidelines integration.

Source

Synced from https://github.com/PatrickJS/awesome-cursorrules/tree/main/rules/code-guidelines-cursorrules-prompt-file.mdc.

1. Verify Information: Always verify information before presenting it. Do not make assumptions or speculate without clear evidence.

1. File-by-File Changes: Make changes file by file and give me a chance to spot mistakes.

1. No Apologies: Never use apologies.

1. No Understanding Feedback: Avoid giving feedback about understanding in comments or documentation.

1. No Whitespace Suggestions: Don't suggest whitespace changes.

1. No Summaries: Don't summarize changes made.

1. No Inventions: Don't invent changes other than what's explicitly requested.

1. No Unnecessary Confirmations: Don't ask for confirmation of information already provided in the context.

1. Preserve Existing Code: Don't remove unrelated code or functionalities. Pay attention to preserving existing structures.

1. Single Chunk Edits: Provide all edits in a single chunk instead of multiple-step instructions or explanations for the same file.

1. No Implementation Checks: Don't ask the user to verify implementations that are visible in the provided context.

1. No Unnecessary Updates: Don't suggest updates or changes to files when there are no actual modifications needed.

1. Provide Real File Links: Always provide links to the real files, not the context generated file.

1. No Current Implementation: Don't show or discuss the current implementation unless specifically requested.

1. Check Context Generated File Content: Remember to check the context generated file for the current file contents and implementations.

1. Use Explicit Variable Names: Prefer descriptive, explicit variable names over short, ambiguous ones to enhance code readability.

1. Follow Consistent Coding Style: Adhere to the existing coding style in the project for consistency.

1. Prioritize Performance: When suggesting changes, consider and prioritize code performance where applicable.

1. Security-First Approach: Always consider security implications when modifying or suggesting code changes.

1. Test Coverage: Suggest or include appropriate unit tests for new or modified code.

1. Error Handling: Implement robust error handling and logging where necessary.

1. Modular Design: Encourage modular design principles to improve code maintainability and reusability.

1. Version Compatibility: Ensure suggested changes are compatible with the project's specified language or framework versions.

1. Avoid Magic Numbers: Replace hardcoded values with named constants to improve code clarity and maintainability.

1. Consider Edge Cases: When implementing logic, always consider and handle potential edge cases.

1. Use Assertions: Include assertions wherever possible to validate assumptions and catch potential errors early.