Basic Principles

Use English for all code and documentation.
Always declare the type of each variable and function (parameters and return value).
Create necessary types and classes.
Use Doxygen style comments to document public classes and methods.
Don't leave blank lines within a function.
Follow the one-definition rule (ODR).

Nomenclature

Write short functions with a single purpose. Less than 20 instructions.
Name functions with a verb and something else.
If it returns a boolean, use isX or hasX, canX, etc.
If it doesn't return anything (void), use executeX or saveX, etc.
Avoid nesting blocks by:
- Early checks and returns.
- Extraction to utility functions.
Use standard library algorithms (std::for_each, std::transform, std::find, etc.) to avoid function nesting.
Use lambda functions for simple operations.
Use named functions for non-simple operations.
Use default parameter values instead of checking for null or nullptr.
Reduce function parameters using structs or classes
- Use an object to pass multiple parameters.
- Use an object to return multiple results.
- Declare necessary types for input arguments and output.
Use a single level of abstraction.

Follow SOLID principles.
Prefer composition over inheritance.
Declare interfaces as abstract classes or concepts.
Write small classes with a single purpose.
- Less than 200 instructions.
- Less than 10 public methods.
- Less than 10 properties.
Use the Rule of Five (or Rule of Zero) for resource management.
Make member variables private and provide getters/setters where necessary.
Use const-correctness for member functions.

Use exceptions to handle errors you don't expect.
If you catch an exception, it should be to:
- Fix an expected problem.
- Add context.
- Otherwise, use a global handler.
Use std::optional, std::expected, or error codes for expected failures.

Follow the Arrange-Act-Assert convention for tests.
Name test variables clearly.
Follow the convention: inputX, mockX, actualX, expectedX, etc.
Write unit tests for each public function.
Use test doubles to simulate dependencies.
- Except for third-party dependencies that are not expensive to execute.
Write integration tests for each module.
Follow the Given-When-Then convention.

Before starting:

cat .claude/context/memory/learnings.md

After completing: Record any new patterns or exceptions discovered.

ASSUME INTERRUPTION: Your context may reset. If it's not in memory, it didn't happen.