Earlier this year, I attended the first Pragmatic Summit, where host Gergely Orosz brought Kent Beck and me on stage for a half-hour discussion. Naturally, AI dominated the conversation, but we also touched on agile methods, TDD, performance metrics, and how to thrive in a world where AI is native to our industry. Later, reflecting on the virtues of a programmer as defined by Larry Wall, and Bryan Cantrill's poignant commentary, I found a thread connecting these ideas. Here are seven key takeaways from that experience.

1. The Pragmatic Summit Conversation with Kent Beck

Gergely Orosz skillfully guided us through a comparison of AI to previous technology shifts. We explored how AI resembles the rise of agile methodologies—both require adaptation but ultimately empower developers to focus on higher-level problems. We debated the role of TDD in an AI-assisted world: while AI can generate test cases, the human judgment to validate them remains crucial. The conversation also highlighted the danger of unhealthy performance metrics—like lines of code written per day—that can mislead teams into prioritizing quantity over quality. It was a refreshing reminder that human insight still defines great engineering.

2. The Three Virtues of a Programmer

In his definitive book on Perl, Larry Wall outlined three virtues: hubris, impatience, and—above all—laziness. Hubris drives us to write code that we're proud of; impatience makes us resent inefficiency; laziness inspires us to create tools that do the work for us. While I never loved the Perl language itself, this triad has stuck with me. Laziness, in particular, is often misunderstood. It's not about doing nothing—it's about working smarter, automating repetitive tasks, and building elegant solutions that save effort in the long run.

3. Laziness as the Most Profound Virtue

Bryan Cantrill has a wonderful take on this virtue: 'Laziness drives us to make the system as simple as possible (but no simpler!)—to develop powerful abstractions that allow us to do much more, much more easily.' The wink here is that it takes a lot of work to be truly lazy. You must understand the problem domain deeply to craft abstractions that eliminate future toil. This perspective elevates laziness from a joke to a core engineering principle—one that encourages clarity, elegance, and sustainable code.

4. The Joy of Building Abstractions

For me, the best part of programming is constructing models that simplify a problem domain. When I find the right set of abstractions, difficulties melt away, and I can achieve far more with far fewer lines of code. It's almost addictive—the buzz of seeing complexity tamed. This process forces me to understand the domain at a deeper level, and each successful abstraction is a small victory. It's the essence of lazy, yet diligent, craftsmanship.

5. The Danger of AI Lacking Laziness

Cantrill worries that because LLMs generate code effortlessly, they lack the virtue of laziness. 'Work costs nothing to an LLM. They do not feel a need to optimize for future time, and will happily dump more onto a layercake of garbage.' Left unchecked, AI can produce systems that are larger but not better, appealing to vanity metrics like lines of code. This is a real risk: we might lose the discipline of building crisp abstractions, which only arises from the constraint of finite human time. AI's limitless capacity could lead to bloated, unmaintainable codebases.

6. Thriving in an AI-Native Industry

So how do we thrive? The answer lies in embracing our human laziness. Because our time is limited, we are forced to develop clean abstractions—something AI cannot do on its own. We must use AI as a tool to accelerate, but not replace, the thoughtful design that makes software sustainable. In the summit conversation, we agreed that developers should focus on architecture, domain modeling, and high-level decisions, letting AI handle boilerplate. This preserves the human's role as the source of wisdom and simplicity.

7. Applying This to Daily Work: A Personal Example

This past Sunday evening, I spent a little time modifying how my music playlist generator works. Instead of hacking together a quick solution, I paused to define a cleaner model of the playlist logic. The result? Fewer lines of code, easier debugging, and a system that can now support new features effortlessly. It was a small act of laziness—investing effort upfront to save much more later. That's the kind of thinking we must retain as AI becomes more prevalent.

In conclusion, the Pragmatic Summit reinforced that while AI is a powerful partner, the core principles of good programming—especially the virtue of laziness—remain irreplaceably human. As Cantrill said, the best engineering arises from constraints. Our limited time forces us to build better systems. Let's not lose that.