Simplicity • Pragmatic Dave Thomas & Sarah Taraporewalla
Dave Thomas, co-author of 'The Pragmatic Programmer,' discusses his new book 'Simplicity,' arguing that modern Agile has failed. He introduces his Orient-Step-Learn framework as a path for individual developers to regain agency, build intuition through deliberate practice, and master the art of creating minimal, elegant solutions by cutting away complexity.
In a conversation with Sarah Taraporewalla, programmer and author Dave Thomas delves into the philosophy behind his new book, “Simplicity,” positioning it as a necessary response to the failures of modern software development practices.
The Failure of “Big A” Agile
Dave Thomas expresses his disillusionment with the current state of what is commonly called “Agile.” He argues that the original spirit of the Agile Manifesto, which he co-signed, was rooted in a set of values meant to guide decision-making. These values provided a filter for choosing better approaches in complex situations.
However, over time, this value system has been replaced by rigid, commercialized processes.
Companies have big processes and developers are basically cogs in a machine. And that’s exactly what we were fighting against when we sat down in Snowbird to craft the manifesto.
He believes “Agile has been implemented” in a way that creates an “impedance mismatch” between agile-practicing teams and the non-agile organizations they exist within. This has led him to seek a “post-agile” world, concluding that the focus must shift from organizational change to what individual developers can control.
The Core Problem: Unchecked Complexity
The central challenge developers face is the relentless growth of complexity. This stems from two sources:
- Developer Habits: A tendency to be attracted to “bright sparkly things” and incorporate them into projects, increasing the burden over time.
- Customer Expectations: A demand for more features and “bright shiny widgety things.”
This ever-increasing burden makes work sluggish and less agile. The solution lies in actively cutting things away to make them simpler, which is a skill developers can cultivate individually.
Simplicity Through Mastery, Not Mandate
A key insight is that simple isn’t easy. True simplicity is not a starting point but an outcome of mastery.
- Beginners tend to bolt various components together without a cohesive vision.
- Masters of a discipline can envision the final result and craft only what is necessary, creating a minimal, elegant solution that “just feels right.”
You cannot just say I want to write something with simplicity. It’s a question of acquiring simplicity… You can’t tell people how to create simplicity. All you can do is show them how to teach themselves.
The Orient-Step-Learn Framework: Building Intuition
To achieve this mastery, Dave proposes a practical, recursive framework: Orient-Step-Learn.
- Orient: Before starting any task, understand your current position, your desired endpoint, and how you will know when you are finished.
- Step: Take the smallest possible step towards your goal. Keeping steps small makes mistakes cheap and encourages experimentation.
- Learn: After the step, look back and reflect on the outcome. What did you learn?
The primary purpose of this loop is to build intuition. Dave defines intuition as “the accumulated experience that you’ve forgotten you have.” The constant, deliberate feedback from the Orient-Step-Learn loop trains the subconscious to recognize patterns, leading to that “gut feeling” about whether code is elegant or flawed. This is the same mechanism that allows your sleeping brain to solve a bug you’ve struggled with all day.
Practical Steps for Individual Developers
The book focuses on actions individuals can take without needing management buy-in. The goal is not immediate ROI, but a “slowly growing sense of mastery.”
- Keep an Engineering Daybook: The simple act of writing things down—ideas, discoveries, solutions—cements them in your mind. It creates an external, associative memory that helps build intuition through reflection.
- Question Everything: Identify things that frustrate you and ask “Why?” Often, the answer is cargo culting—following practices because “that’s how we do it.”
- Experiment by Subtracting: Test your beliefs and practices by temporarily stopping them to see what happens. An agile team that uses the same practices a year later is, by definition, not agile. To achieve simplicity, you must be willing to cut things away.
- Aggressively Manage Dependencies: A new project can pull in thousands of dependencies before a single line of code is written. Each one is a “time bomb waiting to go off.” Be ruthless about their inclusion.
The number of times I see code that drags in tens of thousands of lines of code so they can use a three-line function in the middle of it that they could have just written themselves, right? That kind of thing needs to stop.
The Human Element: Simplifying Interactions
The most challenging area for Dave personally was simplifying human interactions. The core principles here are transparency and empathy. Most disagreements are not zero-sum; the goal should be to combine the best parts of differing viewpoints. He critiques formalisms like daily stand-ups for status reporting as “the most stupid reason on the planet for having a meeting,” as they add impedance and destroy productivity.
Final Takeaway: You Have Agency
The single most important message is that developers have more control than they think.
You are in an unbelievably privileged position that you can literally change the world… We have an immense amount of potential and we have the capability of using that if we just get out of our own way. You have agency.