"how to write sloppy rust code and squander most of the advantages of the language"

Only half serious. But I think really the only point that I agree with is taking the easy way out with the borrow checker. I mean, at least try to borrow when it's idiomatic, but if you get frustrated, clone (or move) instead.

Error handling when done well is not much harder than unwrapping everything, and you get many advantages. Learn to use thiserror for your library crates and anyhow for executables.

I also agree that you should avoid unsafe 99% of the time. If you think you need it, you probably don't.

I agree with 99%, but not sure I see how async is a "fancy feature". When you're writing async code, async is boring and normal. I guess if you are writing programs that don't need to be concurrent it's fine to use sync variants of stuff.

I agree for the most part, with some exceptions

• test the easy things - having a test suite that passes feels good, having some tests makes it easier to add more later, and testing utility code is usually pretty easy and important
• make the important decisions correctly, the rest can be sloppy - e.g. decide early if you need async or multi-threading and get the signatures of your core code right, then take shortcuts on the rest
• don't refactor unless it's blocking new features - it's easy to get sucked into "perfect code," so leave notes instead of doing the refactor

Basically, follow the 80/20 rule, get 80% of the important stuff right for 20% of the effort. Once everything is working, add more tests and refactor while getting feedback from users (if applicable).