The Software Commandments

We aim to be great at software design and development, and to help improve the practice of software engineering as a real engineering discipline. We have learned that this can only be achieved by sharing what we know, and absorbing what others can teach us.

The Software Commandments help to guide the work we do.


  1. Commit to deliver, to help, to learn, and to improve
  2. Be honest, be reliable, work hard. But work smart too – minimise loop time on repeating tasks
  3. When you mess up, own up! And LEARN from your mistakes
  4. Don’t stay stuck, get help! If you’re in a hole, stop digging. If in doubt, keep asking til you’re answered
  5. Communicate! Keep colleagues and clients informed – avoid surprises
  6. Write effectively, speak effectively – keep it short and make it matter to the recipients
  7. Finish your project. Know your deadlines, hit them if you can, shout if you realize you can’t
  8. Solve problems, and help others to solve problems too – everyone learns faster that way
  9. Never leave a mess behind you: this applies to your project, the kitchen AND the bathroom!
  10. K I S S – simplicity is ALWAYS an objective – for ui, code, design, test, process, delivery, documentation
  11. Think for yourself: challenge bad decisions, escalate if necessary – stay calm and polite
  12. Make sure you really understand the project objectives/targets, from the customer and user p.o.v.
  13. Keep a log (paper or digital) and use it every day
  14. Always keep your own backups, and make sure you can restore


  1. Code LESS: every line creates a work-chain. Code is a liability, not an asset
  2. Read the documentation, use existing code if possible. Don’t re-create what already exists
  3. If there isn’t a spec/definition, write a short one (with constraints, goals, non-goals) and agree it
  4. If it isn’t specified as a requirement, don’t code it. If the agreed spec is wrong, challenge it
  5. Understand why code style is important, and comply with existing style
  6. Get someone to review your code. Learn from the reviews, don’t take it personally
  7. Use version control, ideally Git. Commit early and often, (work-in-progress too, at least daily). Push your commits!
  8. Quality code WORKS! All the time
  9. The bug stops here! You are responsible for testing and fixing every line of code you write
  10. Remove uncertainty as fast as possible. Prototype, learn and iterate
  11. Set yourself doable targets every day and every week. If you’re not making daily progress, shout


  1. Test behaviour, not structure. Don’t be gentle, break it!
  2. Write down what you need to test before or at the same time as you write the code
  3. Look for difficult, unexpected cases too
  4. If it can’t be tested, it shouldn’t be there
  5. If there’s a test framework, use it. Aggressively replace/remove tests when things change
  6. If someone else finds a bug after you’ve said it works, kick yourself and improve your practice


  1. Establish constraints and write them down
  2. Plan to remove uncertainty fast – prototype and test against realistic scenarios ASAP
  3. Design for testability, and design defensively: garbage in DOES NOT equal garbage out!
  4. Design should be communicated clearly in writing, pictures or both
  5. The first idea isn’t necessarily best: consider alternatives, discuss
  6. Great design (and leadership) is methodology-independent


  1. Discuss the requirement with others – get perspective
  2. If you’re unsure, say so. If you need more information, ask for it
  3. Break the problem down into component tasks – get someone to challenge the breakdown
  4. Compare like-for-like: try to check against previous productivity on similar work
  5. Estimate the whole job, not just the coding. State what’s included, what’s excluded. State it’s a GUESS
  6. Don’t be over-optimistic. It’s ALWAYS worse than you think


  1. Get the best people you can find/afford, and clear the way so they can be effective
  2. Provide strong leadership – make sure your people know what they need to do, and when
  3. Allow and foster open and honest communication. Listen and learn. React effectively and fairly
  4. Encourage debate where necessary, but if things get bogged down, be a benevolent dictator
  5. Set short timescales for targets and reviews – weekly is probably best.
  6. If you’re squeezed on time and cost, reduce scope – or it’ll be late/broken/over budget
  7. Nail the risks, before they nail you!

Get in touch to find out how Codethink can help you +44 161 660 9930

Contact us