List By: Miko Pawlikowski 
Descriptions By: Jessica Brown
Published: December 29, 2024

Software engineering is a discipline that balances technical precision, creativity, and collaboration. These 17 subtle rules provide insights to improve the quality of code, foster teamwork, and guide sustainable practices.

0. Stop Falling in Love with Your Own Code
When you become too attached to your code, you may resist valuable feedback or overlook its flaws. Always prioritize the quality of the solution over personal pride. It's common for engineers to feel a sense of ownership over their code. While this passion is commendable, it can lead to bias, making it hard to see where improvements or simplifications are needed. Detach emotionally and view feedback as an opportunity to improve, not a critique of your skills.

1. You Will Regret Complexity When On-Call
Overly complex systems are hard to debug, especially during emergencies. Strive for simplicity, making it easier for others (and your future self) to understand and maintain. Complexity often creeps in unnoticed, through clever solutions or layers of abstraction. However, when systems fail, it's the simpler designs that are easier to troubleshoot. Use complexity judiciously and only when it's absolutely necessary to meet requirements.

2. Everything is a Trade-Off. There's No "Best"
Every design decision involves compromises. The "best" solution depends on the context, constraints, and goals of the project. Choosing a database, framework, or algorithm involves balancing speed, scalability, maintainability, and cost. Recognize that no solution excels in every category. Acknowledge the trade-offs and ensure your choices align with the project's priorities.

3. Every Line of Code You Write is a Liability
Code requires maintenance, testing, and updates. Write only what is necessary and consider the long-term implications of every addition. Each line of code introduces potential bugs, security vulnerabilities, or technical debt. Minimize code by reusing existing libraries, automating where possible, and ensuring that each addition has a clear purpose.

4. Document Your Decisions and Designs
Good documentation saves time and prevents confusion. Capture the reasoning behind decisions, architectural diagrams, and usage guidelines. Documentation acts as a map for future developers. Without it, even straightforward systems can become inscrutable. Write with clarity and ensure that your documentation evolves alongside the code.

5. Everyone Hates Code They Didn't Write
Familiarity breeds fondness. Review others' code with empathy, recognizing the constraints they faced and the decisions they made. It's easy to criticize unfamiliar code. Instead, approach it with curiosity: Why were certain decisions made? What challenges were faced? Collaborative and constructive feedback fosters a more supportive team environment.

6. Don't Use Unnecessary Dependencies
Dependencies add risk and complexity. Evaluate whether you truly need an external library or if a simpler, inhouse solution will suffice. While dependencies can save development time, they may introduce vulnerabilities, licensing concerns, or compatibility issues. Regularly audit your dependencies and remove any that are redundant or outdated.

7. Coding Standards Prevent Arguments
Adhering to established coding standards reduces debates over style, allowing teams to focus on substance. Standards provide consistency, making code easier to read and maintain. Enforce them with tools like linters and code formatters, ensuring that discussions focus on logic and architecture rather than aesthetics.

8. Write Meaningful Commit Messages
Clear commit messages make it easier to understand changes and the rationale behind them. They are essential for effective collaboration and debugging. A commit message should explain the "why" behind a change, not just the "what." This helps future developers understand the context and reduces time spent deciphering history during troubleshooting.

9. Don't Ever Stop Learning New Things
Technology evolves rapidly. Stay curious and keep up with new tools, frameworks, and best practices to remain effective. The software industry is dynamic, with innovations appearing regularly. Make continuous learning a habit, through courses, conferences, or simply experimenting with new technologies.

10. Code Reviews Spread Knowledge
Code reviews are opportunities to share knowledge, identify improvements, and maintain consistency across the codebase. Reviews aren't just for catching bugs; they're a chance to mentor junior developers, share context about the codebase, and learn from peers. Encourage a culture where reviews are collaborative, not adversarial.

11. Always Build for Maintainability
Prioritize readability and modularity. Write code as if the next person maintaining it is a less experienced version of yourself. Maintainable code is self-explanatory, well-documented, and structured in a way that modifications don't introduce unintended side effects. Avoid shortcuts that save time now but create headaches later.

12. Ask for Help When You're Stuck
Stubbornness wastes time and energy. Leverage your team's knowledge to overcome challenges more efficiently. No one has all the answers, and seeking help is a sign of strength, not weakness. Asking for assistance early can prevent wasted effort and lead to better solutions.

13. Fix Root Causes, Not Symptoms
Patchwork fixes lead to recurring problems. Invest the time to identify and resolve the underlying issues. Quick fixes may address immediate symptoms but often exacerbate underlying problems. Use tools like root cause analysis to ensure long-term stability.

14. Software is Never Completed
Software evolves with changing requirements and environments. Embrace updates and refactorings as a natural part of the lifecycle. Even after release, software requires bug fixes, feature enhancements, and adjustments to new technologies. Treat software as a living entity that needs regular care.

15. Estimates Are Not Promises
Treat estimates as informed guesses, not guarantees. Communicate uncertainties and assumptions clearly. Overpromising can erode trust. Instead, explain what factors might affect timelines and provide regular updates as the project progresses.

16. Ship Early, Iterate Often
Releasing early and frequently allows you to gather feedback, address issues, and refine your product based on real-world usage. Getting a minimal viable product (MVP) into users' hands quickly provides valuable insights. Iterative development helps align the product more closely with user needs and reduces the risk of large-scale failures.

These rules aren't hard-and-fast laws but guiding principles to help software engineers navigate the complexities of their craft. Adopting them can lead to better code, smoother collaborations, and more resilient systems.