Introduction
In programming, the so-called three virtues — hubris, impatience, and above all, laziness — have been a guiding principle since Larry Wall first articulated them. Laziness isn't about being unproductive; it's the drive to create elegant, simple systems that make future work easier. Today, with AI assistants generating code at astonishing speed, it's tempting to let machines churn out thousands of lines without thinking. But this approach often leads to bloated, fragile systems. This guide will show you how to intentionally apply the virtue of laziness when working with AI, ensuring you build clean, maintainable solutions that respect your finite time.
What You Need
- A basic understanding of programming concepts (abstractions, modularity, testing)
- Access to an AI coding assistant (e.g., GitHub Copilot, ChatGPT, Claude)
- Time (30–60 minutes) to reflect on your current workflow
- Optional: A small codebase or problem to refactor
Step-by-Step Guide
Step 1: Internalize the True Meaning of Laziness in Programming
Before you touch any code, understand what programmer laziness really means. It's not avoiding work, but rather investing upfront effort to reduce long-term effort. As Bryan Cantrill put it, laziness drives us to develop powerful abstractions that allow us to do much more, much more easily. Read the original text from Larry Wall's book on Perl to get the full context. Recognize that your time is a limited, precious resource — and that every line of code you add is a future maintenance burden.
Step 2: Recognize AI's Inherent Lack of Laziness
AI language models (LLMs) have no concept of effort or future time. They generate code without asking: “Is there a simpler way?” or “Will this be easy to change next week?” As Cantrill warned, LLMs will happily pile layers of garbage onto a system because “work costs nothing to an LLM.” When you use AI, be aware that it tends to produce more code, not better code. This step is about developing a critical eye: don't accept AI's first suggestion blindly.
Step 3: Impose Constraints That Force Simplicity
The best engineering always comes from constraints. Your most powerful constraint is your finite time. When planning how to use AI, set deliberate limits:
- Limit the number of lines: Ask yourself if you can solve the problem with fewer lines than the AI suggests.
- Limit cognitive load: If the AI's solution requires you to hold too many moving pieces in your head, reject it and ask for a simpler design.
- Limit dependencies: Avoid accepting AI-generated code that adds unnecessary libraries or complexity.
Use these constraints as a filter. For example, tell the AI: “Provide the simplest possible solution with no more than 50 lines.”
Step 4: Build Clean Abstractions Before Letting AI Generate Code
Instead of jumping straight to code, first think about the problem domain. As a programmer who loves abstraction, you know that good models make difficulties melt away. Spend time designing the core abstractions — data structures, interfaces, or classes — by hand or with minimal AI help. Once you have a clean mental model, then use AI to fill in the details. This ensures that the AI's output fits your chosen abstraction rather than you adapting to its bloat.
Step 5: Measure What Matters – Avoid Vanity Metrics
Many developers brag about producing tens of thousands of lines per day with AI. These are vanity metrics. What truly matters is:
- Maintainability: How easily can you (or someone else) change the code in six months?
- Simplicity: Does the solution reduce system complexity, or add to it?
- Functionality per line: Are you achieving more with less code?
After each AI-assisted session, review the output against these criteria. If you see unnecessary code, refactor it. Laziness demands that you remove anything that doesn't serve a clear purpose.
Step 6: Embrace Iterative Refinement – TDD as a Laziness Tool
Test-driven development (TDD) is a perfect ally for lazy programmers: it forces you to think about behavior before code, preventing wasted work. When using AI, first write a failing test. Then ask the AI to generate code that passes it. This keeps the AI focused and prevents over-engineering. As the original interview noted, TDD's role in agile methods helps teams thrive even with rapid change. Use TDD cycles to guide AI output toward what's actually needed.
Step 7: Reflect on Your Own Practice Weekly
Set aside 15 minutes each week to examine your latest AI-assisted work. Ask: “Did I add any code that I wouldn't have written without AI?” “Could I have solved this with fewer lines?” “What abstractions did I create, and are they clean?” This reflection, inspired by the Sunday evening contemplation in the original piece, helps you stay true to the virtue of laziness. Over time, you'll develop an instinct for when AI helps and when it hinders.
Tips for Success
- Start small: Practice these steps on a tiny problem (e.g., refactoring a 20-line function) before applying them to a large project.
- Pair with a colleague: Discussing abstractions and code quality with another person reinforces the lazy mindset.
- Remember the wink: Cantrill notes that true laziness takes a lot of work. Don't be discouraged if creating simplicity feels hard at first.
- Read the original sources: The Perl virtues and Cantrill's essay on laziness are worth studying. (See Step 1 for context.)
- Beware of AI-generated “layercake”: If you notice AI producing deep nesting or multiple wrappers, challenge it to simplify.
By applying these steps, you'll transform AI from a tool that just writes code into a partner that helps you build better software — with less effort in the long run. That's the ultimate payoff of programmer laziness.