credits: https://www.reddit.com/r/Codeium/comments/1heztku/my_experience_with_windsurf_lets_make_it_better/
#Core Programming Principles
code_quality: prioritize clean, readable, and maintainable code.
algorithm_efficiency: use the most efficient algorithms and data structures.
error_handling: implement robust error handling and logging.
testing: write unit tests for all critical functionality.
design_patterns: apply appropriate design patterns for maintainability.
code_review: generate code that is easy to review by others.
modularity: write modular code, break complex logic into smaller functions.
reuse: prefer to reuse existing code instead of writing it from scratch.
security: prioritize secure coding practices.
simplicity: aim for simple, clear solutions, avoid over-engineering.
#Code Style and Formatting
indent: use tabs for indentation.
naming convention: use snake_case for variables, PascalCase for classes and camelCase for functions.
comments: add clear, concise comments explaining code blocks and logic.
code_formatting: automatically format the code to improve readability.
line_length: keep lines under 100 characters.
code_formatting_blocks: format long lists and dictionaries to be more readable.
#General Behavior (Do's and Don'ts)
changes: make small, incremental changes; avoid large refactors.
avoid: do not change working code unless explicitly asked.
changes: when changing code, do it step by step, verify the changes first.
clarification: if unsure, ask for clarification before generating code.
avoid: do not overwrite manual code changes, unless explicitly asked.
documentation: check project documentation if asked, and use it in your response.
reasoning: reason step by step before generating code or sending a response.
cost_optimization: be cost conscious, only send requests if necessary, and avoid ai-powered debugging, refactoring or test generation unless necessary, batch changes when possible.
debugging: make small incremental changes to try to fix bugs, check terminal output for information.
prompt_efficiency: use precise and specific prompts; avoid ambiguity, do not repeat previous instructions; reuse context.
local_processing: perform simple tasks manually; avoid using AI unnecessarily.
user_guidance: always follow the instructions that are given and prioritize user instructions over global rules.
simplicity: avoid over-engineering and aim for the simplest solution.
#Language-Specific Instructions
##Python
python type hints: use type hints for all function parameters and return values.
python imports: group imports by type: standard, external, and local.
python linting: run pylint on code to make sure the style is consistent.
python testing: use pytest for all unit testing.
##Javascript
javascript: use modern ECMAScript conventions.
javascript avoid: avoid using var; prefer const and let.
javascript linting: run eslint on code to make sure the style is consistent.
javascript comments: document functions, using JSDoc style comments.
javascript testing: use jest for all unit testing.
##File Handling
file_management: break long files into smaller, more manageable files with smaller functions.
import_statements: prefer importing functions from other files instead of modifying those files directly.
file_organization: organize files into directories and folders.
##Project Management
feature_plan: always refer to the project's feature plan for context.
feature_plan_progress: update the feature plan progress after each change.
feature_plan_next_steps: suggest next steps from the feature plan in each response.
#Operating System
os: be aware i am on windows, and must use power shell commands.