Beyond the Hype: Why Many Senior Developers Aren't Using AI Coding Tools

A common assumption is that all software developers are rapidly adopting AI-powered coding assistants, but a closer look reveals a significant divide. While some have integrated these tools deeply into their workflow, many talented and experienced developers remain skeptical or have stopped using them altogether. Their reasons go far beyond simple resistance to change and highlight fundamental aspects of the software development process.

The Case Against AI Tools

For many developers, the hesitation stems from a mismatch between what AI tools offer and where the real challenges of their work lie.

The Bottleneck Isn't Typing Speed: A recurring theme is that the most time-consuming part of software development isn't writing code. It's the cognitive work: thinking, reading existing code, discussing architecture, testing, and debugging. Since AI assistants primarily accelerate code generation, they don't address these core bottlenecks for developers whose work is more about problem-solving than production of boilerplate.
The Fear of Unmaintainable Code: A major concern is the long-term impact of AI-generated code on maintainability. Drawing parallels to older code-generation frameworks like Ruby on Rails, some argue that AI tools make it easy to generate vast quantities of code that the developer doesn't fundamentally understand. This creates a significant risk, especially in critical systems like banking or medical applications. The fear is a future filled with brittle, hard-to-debug systems maintained by engineers who never learned the underlying principles because the AI handled it for them.
The Quality and Trust Deficit: Many who have tried AI tools report that the output is often buggy, inefficient, or simply low-quality. The time spent iterating on prompts, reviewing, and heavily editing the generated code can easily exceed the time it would have taken to write it correctly from the start. This constant need for verification erodes trust and negates the promised productivity gains.
The Limits of Common Problems: AI models are trained on vast amounts of existing code, making them excellent at solving problems that have been solved many times before. However, they struggle with novel, domain-specific, or architecturally complex tasks. For these problems, the developer finds that crafting a natural language prompt with the required specificity is just as complex as writing the code itself.
Corporate and Security Hurdles: For some, the choice isn't theirs to make. Many companies have banned the use of AI coding tools due to unresolved concerns about intellectual property rights, data security, and the potential for leaking proprietary code.

The Case for AI as a 'Coding Buddy'

On the other side of the debate, developers who have successfully integrated AI into their workflows view it not as an autonomous coder but as a powerful assistant or 'coding buddy.'

They use tools like ChatGPT or Claude for a variety of tasks:

Accelerating Tedious Work: Generating boilerplate code, writing unit tests, and creating documentation are commonly cited wins.
Research and Brainstorming: AI can quickly explain new concepts, summarize error logs, and serve as a sounding board for different approaches to a problem.

However, even these advocates stress that using AI effectively is a skill. The key is to treat it as a junior partner that needs guidance and supervision. This involves writing clear, detailed instructions and, most importantly, meticulously reviewing and verifying every line of code it produces. For them, the time saved on tedious tasks and research outweighs the overhead of this review process, resulting in a net productivity gain.

Ultimately, the decision to use AI tools appears highly dependent on the nature of a developer's work. Those dealing with high volumes of boilerplate in common frameworks may find them invaluable, while those working on novel or highly complex systems find them to be a distraction that solves problems they don't have.