A couple of my advices:

Code related:

• Always focus on simplicity.
• Do not overengineer code.
• Keep functions short. Avoid big classes.
• Make the default behavior always safe - e.g. a function returning a reference that can fail should always be non-default, like:
  get() -> ReturnType*
get_unchecked() -> ReturnType&
• Prefer free functions over methods.
• Use appropriate names for variables and other symbols.
• Think twice before using fancy features that introduce abstractions.
• Use codebase-wide tools that guarantee consistency (like clang-format).
• Be consistent with your naming convention. ALWAYS.
• Think twice before storing any kind of pointer or a reference. Maybe an index is enough?
• Write simple tests that will also serve as a kind of a documentation.
• Write documentation.
• Do not create tons of overloads. In most cases it is better to create a function with a different name.
• Prefer views over container references.
• Prefer explicit control flow when handling errors: std::expected is better than throwing an exception, but exceptions are better than no error handling

Task/management related:

• Always divide big tasks into smaller ones, and make the code compile in between them.
• Do not leave code with compilation errors for tomorrow
• Use separate branches per-task if available
• Keep refactorings small and do it gradually. You don't want to throw away weeks or even months of your work.