Can We Think Less with AI?

A reflection on AI-assisted software development and the myth of effortless coding

The Tempting Proposition

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 VSCode with Copilot as my primary environment, with Cursor as my secondary platform for cross-checking and refining solutions.

But after several weeks of experimenting with different approaches to AI-assisted development, I've come to a counterintuitive conclusion: we cannot think less with AI

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:

• 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 Principles 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:

1. 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

2. 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

• Maintained 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.

The Pomodoro 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 VSCode 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 Forward

AI tools for software development are powerful amplifiers of human capability, 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.