Below are a series of principles you should try to keep to when developing code for Veloren
Don't get attached to your code. Expect that everything you write will be poked, prodded, rewritten, refactored, deleted or used in a context you don't envisage. Don't take criticism of your code personally, and realise that all programmers are worthy of criticism at times.
Comment your code, add newlines after distinct processes or operations, name your variables meaningfully (but not lengthily) and say what you mean. Don't try to be unnecessarily clever, don't use syntax that's unnecessarily difficult to understand. Remember: comments should explain WHY, not WHAT or HOW. Future developers don't need obvious comments that parrot the line below them: they need to get inside your head to understand what you're thinking, and explaining WHY you did something helps with that.
Overthinking is an anti-pattern. By opening up a piece of code to a ridiculously wide range of applications, or by trying to abstract everything, it's common to incur overhead, reduce lucidity, increase complexity and make what is already bad code stick around for longer than it needs to. Discuss the problem with other developers beforehand, and then write code that solves just that problem. Don't try to speculate about future development: your code will almost definitely be refactored anyway. It's more important to make code easy to refactor than to make it generic and applicable to an insane range of problems.
Prototyping an idea - either in the Rust playpen, or on a separate branch - is a superb idea. It'll allow you to explore the problem space, understand the problem you're trying to solve better and catch any problems before they muddy your for-real-this-time design gets implemented. Prototyping gives you valuable insights that you simply cannot gain by discussing a problem over and over.
Deleting code is a more valuable exercise than writing code. Refactoring, simplifying, and minimalising is one of the most useful things you can do as a developer. The hundreds of people reading your code months down the line will thank you for it. On top of this, it gives you a chance to go back and fix the horrible mess you created the first time.
Rust is strongly-typed for a reason. Make use of it! If you're writing an API, don't allow the user of that API to feed rubbish into it. Use the type system to constrain them: use enums, custom types, qualifiers (const, immutability, mut, trait constraints, etc.) to prevent people abusing your API. The type system is the single best defender against utter chaos that the world of programming has: You should use it whenever you can to guide your fellow developers towards sensible solutions.
Tests are good! Tests catch logic errors! Tests catch performance problems! Tests catch deadlocks! Tests let us do benchmarks! Add tests! Add them good! Add as many as you can! Become a test-driven legend. Make them meaningful, and make them cover as many use cases as possible.