I’ve been leading small software development teams on big projects since 2004. Painful experiences taught me some simples rules to make it less painful. Here they are, presented in order of discovery:

0. 0. 0. If it can be null, it will be null
      1. The clipboard is a cruel mistress
      2. Size really does matter
      3. Inside every small problem is a larger one, struggling to get free
      4. Every bug you fix creates 2 more
      5. The law of the motorcycle shop is non-negotiable (whoever touched it last is who broke it)
      6. Cleverness is the mother of regret
      7. Just in time requirements are neither
      8. Don’t solve problems you don’t have yet, Nostradamus
      9. Later == never, temporary == forever, shipped > not shipped
      10. Only change 1 thing at a time
      11. Always redo, never fix
      12. Finish the most important feature first
      13. Tomorrow you hates the code you write today, so don’t plan too far ahead
      14. Character data is nvarchar(max) until you can prove otherwise (see rule 2)
      15. Schrodinger’s Spec – you can know what the client wants, or what will be best for them, just not at the same time
      16. Solve the toughest problem first
      17. Legacy == proven. Try out the newest thing on your own time and dime.
      18. Naming stuff is hard
      19. You’re not going to reuse that
      20. Process: never fix, always redo. Code: never rewrite, always fix
      21. Fix problems upstream
      22. Never use a black box when a text file will do
      23. Normalize until it hurts, denormalize until it works
      24. The original sin of code is writing it
      25. An unbound task is the Devil’s workshop
      26. Developer time is vastly more expensive than CPU time