The author confesses that in all their years of software engineering, writing code never felt like the bottleneck. In practice, what consumes the most time in development isn't writing code -- it's the many processes that follow.

Where Are the Real Bottlenecks?

The tasks that require more time and effort than writing code are:

• Code reviews: Carefully reading others' code and finding issues or improvements
• Knowledge transfer: Learning from and teaching each other through mentoring and pair programming
• Testing and debugging: Verifying code works correctly and fixing bugs
• Coordination and communication: The collaboration required when multiple people work together
• Ticket management, meetings, and agile ceremonies: Various procedures for managing and planning work

These processes are essential for maintaining quality, but they actually demand more time and energy than writing code itself. The author puts it this way:

"All of these processes slow us down more than writing code itself. Because they require thought, shared understanding, and sound judgment."

How LLMs Changed the Landscape

Thanks to LLMs like Claude, code can now be produced much faster. This has led to a new narrative: "We've finally solved the code-writing bottleneck!" But the author disagrees.

"The marginal cost of adding new software is approaching zero. But the cost of understanding, testing, and trusting that code? Higher than ever."

In other words, creating code has become easier, but properly understanding and verifying it has actually become harder.

LLMs Only Shift the Weight, They Don't Remove It

While LLMs generate code quickly, the result is that more code floods into systems, placing a greater burden on the people who must review, integrate, and maintain it.

Problems become particularly pronounced in these situations:

1. When the author doesn't fully understand the code they submitted
2. When generated code introduces unfamiliar patterns or breaks team conventions
3. When unexpected edge cases or side effects aren't clear

Ultimately, creating code has become easier, but verifying and trusting it has become more complex. This phenomenon is the old joke of "copy-paste engineering" happening at far greater speed and scale thanks to LLMs.

Understanding Code Is the Real Hard Part

The author emphasizes:

"The greatest cost of code is in understanding it -- not writing it."

While LLMs have sped up code generation, the effort required to logically trace behavior, find subtle bugs, and judge long-term maintainability hasn't decreased at all.

In fact:

• It's becoming harder to distinguish generated code from human-written code
• Understanding why a particular solution was chosen -- the context -- is becoming more difficult

This creates greater challenges for reviewers and teammates.

Teamwork, Trust, and the Importance of Context

Software development has always been fundamentally about collaboration. Shared understanding, alignment on direction, and mentoring are essential.

But when LLMs produce code too quickly, code accumulates without sufficient discussion or review, creating the dangerous illusion that quality is "guaranteed."

This places greater burden on reviewers and mentors. On the surface things may appear faster, but in reality, they may slow down or accumulate more problems.

The Power and Limits of LLMs: The Fundamentals Don't Change

Thanks to LLMs, prototyping, scaffolding, and automation have become genuinely faster. But the importance of clear thinking, thorough reviews, and careful design has only grown.

"The cost of writing code has truly decreased. But the cost of a team understanding that code together has not."

Finally, the author emphasizes:

"That's still the bottleneck. Let's not look away from that fact."

Summary Keywords

• The code-writing bottleneck is an illusion
• Real bottlenecks: code reviews, knowledge transfer, testing, debugging, collaboration
• LLMs accelerate code production but increase the burden of verification and understanding
• The importance of code understanding and teamwork hasn't changed
• Sticking to fundamentals is what truly ensures quality

This article kindly and realistically points out that writing code quickly isn't everything in development, and that understanding, verification, and collaboration are the truly hard parts. Even in the LLM era, it's a reminder of how important a development culture grounded in fundamentals really is.