Do developers need to think less with AI?

The promise of AI-powered development tools is seductive: write natural language descriptions, get working code, move fast, ship features. Tools like GitHub Copilot and Cursor have become staples in many developers' workflows; mine included. I use VS Code with Copilot as my primary environment, with Cursor as my secondary platform for cross-checking and refining solutions.

However, after several weeks of experimenting with different approaches to AI-assisted software development, I've come to a counterintuitive conclusion: we need to think more when assisted by AI, not less.

My initial approach was what I'd call "lazy prompting"— throwing poorly constructed, vague requests at AI tools and expecting magic. Here are examples of the kind of prompts I was using:

1. "The resources created in the rds.tf file could be placed in their own module. How would you go about it? Which variables and outputs are necessary for the module to deliver the functionality?"

2. "Expose the ECS module output for ecr_url in root outputs.tf as well."

These prompts, while technically clear, were asking AI to make too many architectural decisions at once without proper context. Despite having established foundation rules for AI development, I wasn't applying them consistently.

The results were consistently disappointing. They led to:

• Information overload. AI would generate vast amounts of code that technically worked but was difficult to comprehend.

• Constant rollbacks. Every 20 minutes, I found myself undoing changes and starting over.

• Non-iterative code.The output was functional but rigid, making incremental improvements nearly impossible.

• Structural mess. While the code fulfilled requirements, it lacked coherent architecture.

The code worked, but it wasn't good code. More importantly, it wasn't code I could build upon.

Two approaches to AI assistance that work 

I had been using these principles in my earlier AI development work, but my recent experiment with "lazy prompting" confirmed just how essential they are for effective AI assistance.

Small steps

Rather than asking AI to solve large, complex problems in one go, I've learned to break work into smaller, focused increments. This aligns with the principle of taking a lot of tiny steps in software development. This approach:

• Keeps the AI's output manageable and reviewable

• Allows for course corrections before investing too much time

• Maintains code quality by preventing architectural drift

• Enables better understanding of each component

Pair programming with AI

The most significant shift in my thinking came from treating AI as a pair programming partner rather than a code generator. This builds on the established benefits of pair programming while adapting them for AI collaboration.

This means:

• Active engagement. Continuously reviewing and questioning the AI's suggestions.

• Collaborative iteration. Building solutions together rather than accepting wholesale output.

• Maintaining agency. Staying in control of architectural decisions and code quality.

• Continuous learning. Understanding what the AI produces rather than blindly accepting it.

   

This approach mirrors the benefits of traditional pair programming — better code quality, knowledge sharing and reduced bugs — while leveraging AI's strengths in pattern recognition and rapid prototyping. There are risks here, though, and it's important to keep in mind that an AI assistant cannot be a complete replacement for pair programming, which has human interaction and collaboration at its core.

An unexpected Pomodoro Technique connection

An unexpected discovery was how well the Pomodoro Technique complements AI-assisted development. In traditional pair programming, natural breaks occur when your partner steps away for coffee or other needs. These interruptions, while sometimes frustrating, provide valuable thinking time.

When pairing with AI, these natural breaks disappear. The AI never gets tired, never needs coffee and never suggests taking a step back. This can lead to tunnel vision and mental fatigue.

The Pomodoro Technique artificially introduces these crucial breaks, providing time to:

• Reflect on the direction of the work.

• Assess code quality objectively.

• Consider alternative approaches.

• Prevent the cognitive overload that comes from continuous AI interaction.

   

(For VS Code users, extensions like "Pomodoro Timer" can help integrate these breaks directly into your development workflow.)

The thinking paradox

 

The central paradox of AI-assisted development is this: tools that promise to reduce cognitive load actually require more disciplined thinking to use effectively. Success with AI development tools depends on:

• Clear problem articulation. Better prompts lead to better solutions

• Architectural awareness. Understanding how generated code fits into the larger system

• Quality assessment. Evaluating AI output against engineering standards

• Strategic thinking. Knowing when to accept, modify or reject AI suggestions

Moving ahead with AI assistance

AI tools for software development are powerful amplifiers of human capability; they're not replacements for human judgment. They excel at generating boilerplate, suggesting patterns and rapid prototyping. However, they require thoughtful integration into development workflows.

The most effective approach I've found combines the speed and pattern recognition of AI with the architectural thinking and quality standards that experienced developers bring. This isn't about thinking less — it's about thinking differently and more strategically.

The future of AI-assisted development isn't about replacing developer intelligence but augmenting it. The developers who thrive will be those who learn to think clearly about how to direct these powerful tools toward creating maintainable, understandable and robust software.

As with any powerful tool, the key lies not in the tool itself but in the wisdom and discipline of its user.

An earlier version of this post was published on Nik's Substack.