Introduction
The promise of AI-assisted development tools is seductive: describe in natural language, get working code, move fast, ship features. Tools like GitHub Copilot and Cursor have become indispensable in many developers' workflows, including mine, with adoption spreading from side projects to core enterprise codebases in just a couple of years. I use VS Code with Copilot as my primary environment and Cursor as a secondary platform to check and refine solutions.
However, after several weeks of experimenting with different approaches to AI-assisted software development, I arrived at a counterintuitive conclusion: we need to think more when assisted by AI, not less.
The lazy prompting trap
My initial approach was what I'd call "lazy prompting", feeding AI tools poorly constructed, vague requests and hoping for magic. Here are examples of the kind of prompts I was using:
"The resources created in rds.tf could be placed in their own module. How would you go about it? Which variables and outputs are needed for the module to work correctly?" "Also expose the ECS module's ecr_url output in the root outputs.tf."
These prompts, while technically clear, asked the AI to make too many architectural decisions at once without proper context. Despite having established ground rules for AI-based development, I wasn't applying them consistently.
The results were consistently disappointing. They led to:
Information overload. The AI generated huge amounts of technically functional but hard-to-understand code. Constant backtracking. Every 20 minutes I found myself undoing changes and starting over. Non-iterative code. The output worked but was rigid, making incremental improvements nearly impossible. Structural chaos. Even though the code met the requirements, it lacked coherent architecture.
The code worked, but it wasn't good code. More importantly, it wasn't code I could build on. It became clear that fluency in prompting was not the same thing as fluency in software design, the two skills don't automatically transfer.
Two approaches to AI assistance that actually work
I had applied these principles in my earlier AI-assisted development work, but my recent experience with "lazy prompting" confirmed just how essential they are for effective AI assistance.
Breaking work into small steps
Small steps, Instead of asking the AI to solve large, complex problems in one shot, I learned to break work down into small, focused increments. This aligns with the principle of taking many small steps in software development. This approach:
Keeps AI output manageable and verifiable; Allows course correction before investing too much time; Preserves code quality by preventing architectural drift
Enables a better understanding of each component
Treating AI as a pairing partner
Pair programming with AI, The most significant shift in how I think was treating AI as a pair-programming partner rather than a code generator. This builds on the well-established benefits of pair programming while adapting them to collaboration with AI.
This means:
Active engagement. Continually reviewing and challenging the AI's suggestions. Collaborative iteration. Building solutions together rather than accepting output wholesale. Maintaining agency. Staying in control of architectural decisions and code quality. Continuous learning. Understanding what the AI produces rather than accepting it blindly.
This approach mirrors the benefits of traditional pair programming, better code quality, knowledge sharing and fewer bugs, while leveraging AI's strengths in pattern recognition and rapid prototyping. There are risks, however, and it's important to remember that an AI assistant cannot fully replace pair programming, which has human interaction and collaboration at its core: an AI partner never pushes back with the kind of contextual judgment a human colleague brings, so the discipline of questioning its output has to come entirely from you.
An unexpected connection with the Pomodoro technique
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. Those interruptions, while sometimes frustrating, provide valuable thinking time.
When pair programming with AI, those natural breaks disappear. The AI never gets tired, never needs coffee, and never suggests stepping back, it will happily keep generating suggestions for hours on end. This can lead to tunnel vision and mental fatigue, and the absence of any built-in friction makes it easy to lose track of how much unreviewed code has accumulated.
Reintroducing reflection breaks
The Pomodoro technique artificially introduces these crucial breaks, providing time to:
Reflect on the direction of the work. Objectively assess code quality. Consider alternative approaches. Prevent the cognitive overload that results from continuous interaction with AI.
(For VS Code users, extensions like "Pomodoro Timer" can help build these breaks directly into your development flow.)
The paradox of thinking
The central paradox of AI-assisted development is this: the tools that promise to reduce cognitive load actually require more disciplined thinking to be used effectively, precisely because the bottleneck shifts from typing code to judging it. Success with AI-assisted development tools depends on:
What good AI usage actually requires
Clear problem articulation. Better prompts lead to better solutions. Architectural awareness. Understanding how generated code fits into the broader system. Quality evaluation. Assessing AI output against engineering standards. Strategic thinking. Knowing when to accept, modify or reject AI suggestions
Moving forward with AI assistance
AI tools for software development are powerful amplifiers of human capability; they are not replacements for human judgment. They excel at generating boilerplate code, suggesting patterns and rapid prototyping. However, they require thoughtful integration into development workflows, with clear checkpoints for review rather than open-ended delegation.
The most effective approach I've found combines the AI's speed and pattern recognition with the architectural thinking and quality standards that experienced developers bring. It's not 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 succeed 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 the person using it.
An earlier version of this article was published on Nik's Substack.
Disclaimer: The statements and opinions expressed in this article are those of the author(s) and do not necessarily reflect the positions of Adservio.
STAY POSTED
Get our next analyses and field notes straight to your inbox.
