The Art of Legitimate Slacking: From Code Compilation to AI Generation Waits for Programmers

From Compilation Waits to AI Generation: The Programmer's "Legitimate Slacking"

"I'm not slacking off, my code is compiling" — this classic programmer joke has recently gone viral again on social media. Originating from an XKCD comic, this timeless quip has taken on entirely new meaning in the age of AI-assisted programming.

The Past and Present of a Classic Meme

Compilation Waits: The Programmer's Traditional Excuse

In traditional software development, code compilation is an unavoidable waiting process. Compiling large C++ projects can take anywhere from tens of minutes to several hours, during which programmers genuinely have nothing to do. The lengthy compilation times in C++ have deep technical roots: its header file inclusion mechanism (#include) requires each source file to expand all included headers during compilation, and in large projects, a single source file can balloon to hundreds of thousands of lines after expansion; Template Metaprogramming requires the compiler to perform extensive type deduction and code instantiation at compile time; and the linking stage must merge hundreds or even thousands of compilation units while resolving symbol references. Google's Chromium browser project once reported that a full build took over 6 hours, and even with incremental compilation and distributed build tools (like distcc and ccache), recompilation after major changes could still take tens of minutes.

Notably, compilation time isn't a problem exclusive to C++ as a historical artifact. Modern languages face similar challenges: Rust's strict ownership checking and monomorphization of generics have made compile times a perennial hot topic in the community, with full builds of large Rust projects also potentially taking minutes to tens of minutes. To address this, the industry has developed a series of modern build systems — Google's Bazel, Meta's Buck2, and Microsoft's MSBuild — which refine incremental compilation granularity from the file level to the rule level through precise dependency graph analysis, content-addressed caching, and remote execution capabilities, dramatically reducing unnecessary recompilation. Yet even with these tools, large-scale recompilation remains unavoidable when developers modify core underlying libraries or update compiler versions.

Years ago, XKCD perfectly captured this scenario in a comic — when your boss questions why you're goofing off, "my code is compiling" is the ultimate shield. XKCD is a webcomic created by former NASA robotics engineer Randall Munroe, known for its stick-figure art style. Since its founding in 2005, it has become one of the most influential cultural icons among programmers and scientists. Munroe later published the What If? book series, using rigorous scientific methods to answer absurd hypothetical questions, further cementing his status in tech culture. Comic #303, "Compiling," is the classic in question — it depicts two programmers pushing each other around the office in chairs, responding to questioning with "our code is compiling." The comic has endured because it precisely captures a real pain point in software development: during compilation, developers are genuinely in a state of "legitimate idleness," which to outsiders looks indistinguishable from slacking off.

A New Interpretation for the AI Era

Today, this phrase carries a much richer context. With the proliferation of AI programming tools like GitHub Copilot, Cursor, and Claude, programmers' workflows have undergone fundamental changes. Current AI programming tools have formed a multi-layered ecosystem: GitHub Copilot launched in 2021, built on the OpenAI Codex model, providing line-level and function-level code completion as an IDE plugin, now with over 1.8 million paid users; Cursor is an AI-native IDE deeply rebuilt on VS Code, integrating large language models into editing, searching, refactoring, and other workflows, supporting context-aware conversational programming across entire codebases; Anthropic's Claude excels with its ultra-long context window and powerful reasoning capabilities, particularly adept at understanding complex code logic and performing large-scale refactoring. Beyond these, Amazon CodeWhisperer (now renamed Amazon Q Developer), Google's Gemini Code Assist, and open-source community tools like Continue and Cody together form a rapidly evolving AI programming ecosystem.

All these tools rely on large language model (LLM) inference under the hood — models need to generate output token by token, and complex requests may require seconds to tens of seconds of processing time, constituting the new era's "compilation wait." From a technical perspective, large language models use an autoregressive generation mechanism, producing only one token at a time (typically a word or subword), with each new token's generation depending on the entire sequence of previously generated tokens. This means generating a 500-token code snippet requires 500 forward inference passes. Although the industry has developed optimization techniques like KV Cache, Speculative Decoding, and Continuous Batching to accelerate inference, for complex programming tasks requiring deep reasoning — such as understanding thousands of lines of code context before generating a precise refactoring plan — wait times remain significant. Especially when models need to process ultra-long contexts (e.g., 100K+ token codebases), the computational complexity of the attention mechanism further increases response times.

Specifically, new waiting scenarios include:

• Waiting for AI to generate code: After describing requirements to the AI, waiting for the model to return results
• Waiting for AI to review code: Having AI check for potential bugs and optimization suggestions
• Waiting for AI to refactor: Handing large-scale code refactoring over to AI
• Waiting for AI to explain code: When facing unfamiliar codebases, having AI analyze code logic and architectural design

These new "wait times" are essentially the same as compilation waits — you are indeed working, except the executor has shifted from the compiler to AI.

Programmer Culture and the Productivity Paradox

Looks Like Slacking, Actually Thinking

Software development has never been purely a "typing" job. Research on how programmers actually spend their time has a long history. A large-scale survey by Microsoft Research in 2019 found that developers spend only about 4 hours per day in a "deep coding" state, with the remaining time devoted to reading code, attending meetings, thinking through design solutions, and communicating with colleagues. Even earlier research — Tom DeMarco and Timothy Lister's classic book Peopleware — pointed out that programmers need an average of 15 minutes of uninterrupted focus to enter a "flow" state, and recovering flow after an interruption requires equally long. First published in 1987, this book is still regarded as the bible of software engineering management, with its core argument being that the biggest problems in software development aren't technical but sociological — office environments, team culture, and management practices impact productivity far more than the choice of technical tools.

In recent years, "Developer Experience" (DevEx) has become a hot research area in software engineering. In 2023, researchers from GitHub, Microsoft Research, and the University of Victoria jointly proposed the SPACE framework, measuring developer productivity across five dimensions: Satisfaction and well-being, Performance, Activity, Communication and collaboration, and Efficiency and flow. This framework explicitly states that pure activity metrics (such as commit counts or coding hours) cannot represent true productivity — developers' cognitive load, job satisfaction, and frequency of entering flow states are equally critical indicators. This provides academic support for "legitimate slacking" — forcing developers to maintain continuous keyboard output not only fails to improve productivity but may actually reduce code quality through cognitive overload.

Excellent programmers spend far more time thinking and designing than actually coding. Compilation waits and AI generation waits are, in a sense, manifestations of this "non-keyboard time." The "Incubation Effect" in cognitive science also shows that temporarily stepping away from a problem can actually facilitate creative solutions — meaning those seemingly "slacking" moments of waiting may be precisely when the brain is processing complex problems in the background. Neuroscience research has found that the brain's "Default Mode Network" is most active when a person is relaxed or mind-wandering, and this network is closely associated with creative thinking, problem-solving, and long-term memory consolidation.

The Efficiency Debate Around New Tools

Interestingly, while AI tools have accelerated code generation, they've also created new waiting scenarios:

1. Prompt Engineering: Crafting how to describe requirements to AI takes time in itself. Prompt Engineering is far more than simply asking AI a question — it's an emerging discipline about how to structurally convey intent to large language models. In programming contexts, high-quality prompts need to include clear functional requirement descriptions, tech stack constraints (such as language and framework versions), code style preferences, boundary conditions and error handling requirements, and necessary context code snippets. Research shows that for the same programming task, prompts of different quality can lead to order-of-magnitude differences in AI output quality. Advanced techniques include Few-shot Prompting, Chain-of-Thought prompting, and role-setting. This ability to "program in natural language" is becoming one of developers' core competencies. It's worth noting that as model capabilities improve, prompt engineering itself is evolving — from the early days requiring carefully crafted complex prompts to today's models increasingly understanding concise, straightforward natural language instructions, the field is undergoing a shift from "technique-driven" to "intent-driven."

2. Result Verification: AI-generated code requires manual review and testing. Large language models suffer from "hallucination" problems, potentially generating code that appears reasonable but actually contains logic errors, security vulnerabilities, or performance issues. Developers need sufficient expertise to judge the correctness of AI output, and this review work itself is intensive cognitive labor. Specifically, common issues with AI-generated code include: using deprecated APIs (due to training data time lag), ignoring concurrency safety, generating code with SQL injection or XSS vulnerabilities, and oversights in boundary condition handling. This requires developers to evaluate not just functional correctness but also security, performance, maintainability, and other dimensions.

3. Iterative Dialogue: Multiple rounds of interaction with AI until satisfactory results are achieved. Complex programming tasks often require multiple conversation rounds to progressively refine requirements, correct errors, and adjust implementation approaches — a process similar to pair programming with an experienced but occasionally error-prone colleague. In fact, "AI Pair Programming" has become the standard term for describing this work pattern. Compared to traditional human-human pair programming, AI pair programming is unique in that: AI never gets tired or impatient and can switch between tech stacks and programming languages at any time, but it also lacks deep understanding of project business context and tacit knowledge of team collaboration norms.

This means the excuse "my code is compiling" hasn't just survived — it now has more variants: "I'm waiting for AI to respond," "AI is helping me refactor," "I'm reviewing the code AI wrote."

Implications for Developer Workflows

Embrace Asynchronous Workflows

Whether it's compilation or AI generation, smart developers have long learned to make use of these intervals:

• Switch to another task
• Read technical documentation
• Think about architectural design
• Or — take a well-deserved break

This work style aligns perfectly with the Pomodoro Technique — human attention is a finite resource, and moderate breaks not only don't reduce efficiency but actually help the brain recover and maintain high output over extended periods. In AI-assisted programming workflows, the intervals waiting for AI responses naturally provide developers with these "micro-break" opportunities. In fact, some cutting-edge development teams have begun consciously designing "AI-first" workflows: breaking large tasks into multiple subtasks that can be submitted to AI in parallel, reviewing one AI's output while waiting for another AI's response, forming an efficient "human-machine alternation" rhythm. This pattern bears a striking resemblance to the "round-robin" scheduling algorithm in operating systems — maximizing overall throughput through rapid context switching.

Redefining "Productivity"

In the era of AI-assisted programming, the standards for measuring programmer productivity are changing. It's no longer about how many lines of code you write per day, but whether you can effectively collaborate with AI, ask the right questions, and verify the quality of AI output. In fact, "lines of code" as a productivity metric was abandoned by the industry long ago — Bill Gates once said, "Measuring programming progress by lines of code is like measuring aircraft building progress by weight." In the AI era, a developer who can use a precise prompt to have AI generate 500 lines of high-quality code in 30 seconds is far more valuable than one who manually types the same code over several hours. The key competency is shifting from "writing code" to "defining problems, validating solutions, and maintaining quality."

Industry data corroborates this trend. A research report published by GitHub in 2022 showed that developers using Copilot completed programming tasks 55% faster than those who didn't, with significantly higher self-reported job satisfaction and "flow" experiences. A 2023 McKinsey analysis indicated that generative AI tools can improve coding and documentation efficiency in software development by 20-45%, while emphasizing that these efficiency gains are primarily concentrated in "well-defined" tasks — requirements analysis, system design, and cross-team coordination still heavily depend on human judgment. This means AI tools are reshaping developers' role positioning — from "code producers" to "system architects and quality gatekeepers." The most valuable developers of the future may not be the fastest typists, but those most skilled at translating ambiguous business requirements into precise technical specifications and identifying potential risks in AI output.

Conclusion

The reason this simple tweet resonates is that it touches on every programmer's daily experience. From the long compilations of the C era to the model inference waits of the AI era, the essence of "legitimate slacking" has never changed — good software development requires space for thinking, and these moments of waiting are precisely when creativity is brewing.

Technology keeps evolving and tools keep iterating, but one thing remains constant: the best code is never hammered out on a keyboard — it's conceived in the mind. Whether you're waiting for the compiler to finish or for an AI model to return results, that time when you appear to be "doing nothing" may be your most valuable working time. As computer science pioneer Edsger Dijkstra said: "Computer science is no more about computers than astronomy is about telescopes." The core of programming has always been thinking, and tools — whether compilers or AI — are merely the medium for turning thought into reality.