"Any fool can write code that a computer can understand. Good programmers write code that humans can understand."
This maxim, immortalized by Martin Fowler in his classic Refactoring (1999), sums up a truth that every technology professional learns the hard way after a few years in the field: programming is not just about making things work. It is about communicating intent. It is about building something that another person (or yourself six months from now, during a late-night incident) can read, understand, modify, and evolve without fear. Code written without technical purpose turns into debt.
Often, in the heat of weekly deliveries, we treat internal software quality as if it were an aesthetic whim of purists, something separate from business results. In practice, the exact opposite occurs: the way we write and care for a system determines both the future speed of the company and the mental health of those who work in it.
Why does craftsmanship matter? Autonomy, Mastery, and Purpose
To understand why good engineers suffer so much when they are forced to deliver poorly made code continuously, we need to look at the science of human motivation.
In 2000, psychologists Edward Deci and Richard Ryan, from the University of Rochester, consolidated decades of empirical studies in Self-Determination Theory. Later, in 2009, author Daniel Pink popularized these findings in the book Drive: The Surprising Truth About What Motivates Us. The central conclusion of this research is that, in complex cognitive and creative tasks, purely mechanical rewards and punishments do not sustain high performance. What drives top-tier professionals are three intrinsic pillars:
- Autonomy: the space of trust to make conscious decisions about how to solve the problem.
- Mastery: the human desire to continuously improve in a skill that matters and take pride in the technical quality of one's craft.
- Purpose: the clarity that that work connects to something bigger, making life easier for the end user and for fellow team members.
When an engineering culture reduces the developer to a "ticket closer" who just pushes patches to production without time to think about architecture, it destroys mastery and empties purpose. The professional stops caring. And a system maintained by people who have stopped caring degrades at a frightening speed.
Clear signs of code without purpose
It is enough to open the repository of a neglected project for fifteen minutes to recognize the absence of technical purpose. The symptoms are universal:
- Enigmatic variable and function names: obscure abbreviations (
data2,procTmp,handleStuff) that force the reader to decipher line by line what should be explicit. - Functions with 500 lines: monolithic blocks that mix tax rules, database calls, text formatting, and email sending in the same place.
- No reliable tests: or worse, fragile tests that nobody runs because they break for any irrelevant reason.
- Lying comments: texts written two years ago that describe behavior the code no longer executes.
- Infinite copy-paste: the same business rule duplicated in eight different files, ensuring that the next change will fix seven places and forget one.
What DORA science shows about quality and burnout
In the book Accelerate: The Science of Lean Software and DevOps (2018), researchers Nicole Forsgren, Jez Humble, and Gene Kim analyzed thousands of technology organizations around the world within the DORA (DevOps Research and Assessment) program.
The data permanently dismantled the myth that "to go fast you have to give up quality." The elite teams evaluated by DORA proved that speed and stability go hand in hand. More than that: the research demonstrated statistically that modular codebases, automated test coverage, and continuous delivery practices drastically reduce deployment pain and burnout.
Engineers who see the impact of their code on the end user and who operate on a clean technical base make fewer mistakes, recover from failures in minutes, and feel real pride in what they put into production.
Four principles of purposeful code
Transforming technical purpose into routine does not require complex ceremonies. It demands daily discipline in four fundamentals:
1. Readability first
Classic software engineering studies show that we spend much more time reading and navigating existing code than typing new lines. Therefore, optimize for human reading. Prioritize clarity over cleverness. Simple, straightforward code that any team member understands in thirty seconds is infinitely more valuable than syntactic gymnastics that only the author understands.
2. Tests as living documentation
Good automated tests are not just for catching bugs before deployment. They explain, with executable examples, exactly what the system should do in each business scenario. When a newcomer joins the team, a well-written test suite is the safest map for them to understand product rules and change code with courage.
3. Continuous refactoring
Do not leave cleanup for a "refactoring sprint" that will never be approved by management. Apply the boy scout rule every day: leave the module a little cleaner than it was when you opened it. Small, constant improvements in names, function extraction, and duplication removal prevent traumatic rewrites in the future.
4. Code review as an engineering ritual
Code review is not bureaucracy to click "approved" in thirty seconds, nor a vanity arena to dispute who knows more. It is a collective ritual of learning, standardization, context transfer, and operational safety.
The true cost of haste
Yes, delivering fast matters. The market does not wait, and companies need to validate hypotheses with agility. But there is a brutal difference between simplifying scope to deliver fast and destroying quality to fake speed.
Code delivered in a rush, without criteria and without tests, which requires three times more hours of rework and firefighting the following month, was not a fast delivery: it was a loan taken at extremely high interest rates.
As a technical professional, it is part of your responsibility to learn to negotiate deadlines, translate risks into financial impact language, and explain trade-offs with transparency. Do not passively accept impossible schedules if you know the result will be invisible liability that will stall operations shortly down the road.
The legacy begins today
You are, at this very moment, writing someone's legacy code. What kind of professional inheritance do you want to leave?
The system you push to production today will probably be maintained for years. Maybe by yourself, maybe by a colleague who just arrived, or by an intern who hasn't even been hired yet. Write every function, every test, and every commit message with the goal of making that person's life easier.
Technical purpose, at the end of the day, is just that: concrete respect for the future and for those who walk by our side.
Continue deepening your knowledge: read also The End of DevOps As We Know It and Complete Guide to Scalable Architecture. Explore as well the practice of DevOps Engineering and Critical Architecture, the Diagnostic Tools, and the Case Studies.
References and verifiable readings
- Deci, E. L., & Ryan, R. M. (2000). Self-determination theory and the facilitation of intrinsic motivation, social development, and well-being. American Psychologist, 55(1), 68-78.
- Pink, D. H. (2009). Drive: The Surprising Truth About What Motivates Us (Motivação 3.0). Riverhead Books.
- Forsgren, N., Humble, J., & Kim, G. (2018). Accelerate: The Science of Lean Software and DevOps. IT Revolution Press.
- Fowler, M. (2018). Refactoring: Improving the Design of Existing Code (2nd ed.). Addison-Wesley Professional.
Good ideas keep the conversation going.
Share this article or publish the visual deck to your Stories and Feed.

Cesar Zanis
15+ years leading software architecture, database performance, FinOps, and applied AI across enterprise operations. Built and scaled an engineering organization from zero to 20+ developers.
Enjoyed this article?
I publish practical analyses on critical systems architecture, Cloud FinOps, data, AI, and engineering leadership directly on LinkedIn.
Continue Reading
Take this analysis further with data and sources
All visual cards of this article are ready above to share on your Stories, Feed, WhatsApp, or LinkedIn with full sources.



