AI Changed the Bottleneck of Software Development

Isamu Arimoto — Thu, 23 Jul 2026 08:27:52 +0000

For decades, software engineering was constrained by one thing: writing code.

Today, that bottleneck is disappearing.

With tools like Claude Code, Codex, and other coding agents, generating thousands of lines of code is almost free. The new constraint is no longer how fast we can write code—it's how fast we can keep a codebase healthy.

That is a fundamentally different problem.

AI Doesn't Create Bad Code. It Creates Code Too Easily.

Modern coding agents are remarkably good at producing working code.

But they also tend to:

create another helper function instead of reusing an existing one
leave dead utilities after refactoring
grow functions to hundreds of lines
fall back to any when type inference becomes difficult
introduce subtle architectural violations that are hard to notice in code review

None of these are catastrophic individually.

Together, they slowly increase technical debt.

The challenge isn't intelligence—it's scale.

When an AI can generate code 10× faster than a human, it can also generate technical debt 10× faster.

Human Code Review Doesn't Scale Either

Even experienced reviewers can't remember a 300,000-line codebase.

Suppose a pull request adds another truncate() function.

Is there already one somewhere else?

Maybe.

Maybe there are six.

No reviewer can reliably answer that from memory.

The same applies to unused exports, circular dependencies, or architectural boundaries.

These aren't problems humans should spend their time searching for.

They're mechanical problems.

Let Machines Enforce Code Hygiene

The obvious solution is to automate the boring parts.

Our development workflow combines several layers of static analysis:

ESLint for complexity and coding standards
SonarJS for maintainability and type safety
jscpd for duplicated code
Knip for dead code detection

Each tool catches a different class of problems.

No single tool is sufficient.

Together, they continuously protect the codebase while developers—and AI agents—focus on solving actual problems.

DRY Matters Even More in the AI Era

Many people think DRY ("Don't Repeat Yourself") is mainly about maintainability.

Today, it has another benefit.

AI agents consume context.

Six duplicated implementations don't just increase maintenance cost—they also increase token consumption.

Large functions require more context.

Duplicate utilities require more searching.

Dead code increases noise.

A cleaner codebase is also a cheaper codebase for AI.

Good architecture now directly improves AI efficiency.

CI Should Prevent Regression, Not Punish History

One lesson we've learned is that not every static analysis tool should block a pull request.

Some checks can accurately identify new problems.

Those belong in CI.

Others can only report the current state of the repository.

Those should provide visibility rather than block development.

The goal isn't to eliminate all technical debt overnight.

The goal is simple:

Never create new debt faster than you remove the old one.

The New Engineering Skill

As AI continues to improve, writing code becomes less valuable as a competitive advantage.

The differentiator shifts toward something else:

Designing systems that remain understandable, modular, and maintainable—even when most of the code is written by machines.

Software engineering is becoming less about typing code and more about managing the quality of an ever-growing codebase.

The bottleneck has moved.

The teams that recognize this early will build software faster—not because their AI writes more code, but because their systems stay clean enough for AI to keep writing it.

DEV Community: Isamu Arimoto

AI Changed the Bottleneck of Software Development