Beyond Vibe Coding: What I Discovered Testing 10 AI Coding Tools
Or "An AI Skeptic spends a month with AI coding tools"
After spending the last month tinkering with pretty much every AI coding tool I could get my hands on, I figured it was time to share what I've learned. I remember when we just had a simple language server (LSP) and maybe some autocomplete...and that wasn't that long ago. In 2025, we've gone from "hey, that suggestion is kinda neat" to an entirely different landscape of AI-powered development.
And I have to admit something: I was skeptical.
Skeptic to Explorer
I've been writing code since before Stack Overflow existed. I remember when Google became an essential coding tool, when we moved from books and documentation to search engines as our primary reference. Each shift brought initial resistance ("real programmers memorize everything!") followed by widespread adoption once the productivity gains became undeniable.
When GitHub Copilot first launched, I treated it as a novelty—sometimes helpful for boilerplate, but nothing revolutionary. I was fairly certain AI would never understand the nuanced, context-dependent reasoning that makes software development as much art as science.
But something changed over the past few months. While working on a complex feature involving a state management refactor, I found myself pair programming with an AI. Not just accepting autocomplete suggestions, but genuinely collaborating on architecture, identifying edge cases, and iteratively improving the solution.
That's when it hit me: this wasn't just an evolution of autocomplete. This was a fundamental shift in how we develop software. AI wasn't replacing me—it was partnering with me, much like Google and Stack Overflow had become partners in the past, but with far more active participation in the creative process.
This wasn't "vibe coding" (letting AI generate code without real understanding). This was what others have started calling "vibe engineering"—a collaborative dance between human creativity and machine capability that's greater than the sum of its parts.
The Experiment: My 30-Day Challenge
Intrigued by this revelation, I decided to go all in. I'd spend one month immersing myself in every AI coding tool I could get my hands on. I wanted to understand not just what these tools could do, but how they might change my approach to problem-solving.
Furthermore, I set some ground rules:
Try a different tool each working day for tasks of varying complexity
Document successes, failures, and surprises
Remain skeptical but open-minded
Pay attention to how my own workflow and thinking patterns changed
My goal wasn't to find "the best" AI coding tool—I suspected different tools would excel in different contexts or with different types of tasks. Instead, I wanted to understand how these tools might fundamentally change the development experience.
Tools I Tried
Over the course of the month, I experimented with about a dozen different AI coding tools. Here's a rundown of the major players and my initial impressions:
GitHub Copilot: The most mainstream option felt like a natural extension of my IDE. The inline suggestions were generally helpful, though limited in scope. Copilot Chat proved more versatile but required more explicit prompting. To be fair, this was before they launched an agent mode in VSCode, which appears to be GitHub attempting to catch up to others in this space.
Cursor: Built on VS Code but optimized for AI interaction from the ground up. The Agent mode surprised me with its ability to tackle complex tasks across multiple files, though I sometimes felt like I was working in Cursor's world rather than it adapting to mine. And Cursor also makes a LOT of opinionated choices in both the UI and ergonomics of the IDE itself which seem to be outside the scope of “AI coding assistance” in my mind.
Cline: A VS Code extension that bridges the gap between editor and terminal. Its ability to understand project context was impressive, and I appreciated how it let me maintain my existing workflow while adding AI capabilities where needed. However, again I struggled a little bit with some of the decisions that seemed to be made for me and/or from a kind of “parental” perspective.
Roo Code: A fork of Cline with some unique features like "modes" for fine-tuned repository behavior and Boomerang Tasks for breaking down complex work. The improvements were thoughtful and showed how rapidly this space is evolving.
Windsurf: Formerly Codeium, is a VS Code-based tool with a clean UI. Its "Cascade" feature offers deep codebase context. It suggests terminal commands, fixes linting errors, and shows real-time dev server changes before acceptance. Priced at $15/month, it's a good value, although the pricing model isn't entirely transparent. (and changed as I was going to publish)
Augment Code: Marketed as an AI assistant specifically for professional developers working with large codebases. Their focus on context understanding was key to this positioning - with a large token context window and support. What impressed me was their benchmark performance, especially for real-world tasks rather than artificial tests. Their enterprise security features were robust, though at $30/month (+ “talk to sales” for enterprise pricing), it's definitely positioning itself as a premium option for “serious” development teams.
Devin: Marketed as a "fully autonomous developer," Devin initially seemed like sci-fi overkill. However, for certain isolated tasks, having an agent that could plan, execute, and validate independently was surprisingly efficient—though I wouldn't trust it with critical systems. It feels more like when I was talking to early LLMs about important topics…and they would hallucinate and go down very unexpected paths with way more confidence than they should.
Claude Code: A terminal-first approach that appealed to my command-line habits. While less visually polished than some alternatives, its simplicity and focus on solving one problem at a time matched how I already work. I have never - despite trying - been a Neovim purist, but I suspect if I was, this might be the gateway for me.
Aider: Another outside-of-the-IDE option - Aider works directly in your terminal as an AI pair programming assistant. Instead of requiring a custom IDE, it integrates with your existing Git workflow, making it feel more like a natural extension of tools you already use rather than a wholesale replacement. I appreciated how it builds a map of your entire repository and makes intelligent, version-controlled changes with automatic commits.
What became clear was that each tool had a distinct personality and approach. Some acted more as assistants, others as agents; some prioritized integration with existing workflows, others created new environments optimized for AI collaboration.
Birth of "Vibe Engineering"
The most profound insight from my experiment came about two weeks in. I realized there's a critical distinction between what we’ve seen with "vibe coding" and what I've started thinking of as "vibe engineering."
"Vibe coding" is what most skeptics imagine AI coding to be: throwing prompts at a model and getting back chunks of code that look right but might be conceptually flawed. It's a party trick that falls apart when applied to real systems.
"Vibe engineering," on the other hand, is something far more interesting. It's using AI as a true collaborator in the engineering process—brainstorming architectures, exploring edge cases, refactoring for clarity, and discussing tradeoffs.
A concrete example: I was working on optimizing a data processing pipeline with heavy recursive operations. Traditionally, I would have spent hours with profiling tools, making incremental improvements based on bottlenecks I identified.
Instead, I found myself in a dialogue with the AI:
I explained the performance issue and current implementation
It suggested three potential optimization approaches with tradeoffs
We explored each approach, with the AI providing sample implementations
Together, we refined the most promising solution
I guided the final implementation decisions based on constraints the AI couldn't know
The result wasn't just faster code—it was a solution I likely wouldn't have discovered on my own, at least not in that timeframe. The AI's ability to rapidly explore solution spaces complemented my ability to judge which approaches made sense in our specific context.
This wasn't a human following AI instructions, nor was it AI simply executing human commands. It felt a lot more like genuine collaboration—each party contributing their strengths to reach a better outcome together.
Evolving, Not Replacing
Throughout this experiment, one thing became increasingly clear: AI isn't replacing developers—it's changing what development means.
The skills that make developers valuable are evolving (aren’t they always?). Raw coding ability matters less when AI can generate syntactically correct code from high-level descriptions. Instead, other skills become more important:
System design and architecture: The ability to see the big picture and design cohesive systems that solve real problems
Problem framing: Clearly articulating what needs to be solved and why
Evaluation and judgment: Critically assessing AI-generated solutions for correctness, maintainability, and alignment with broader goals
Contextual knowledge: Understanding the business domain, user needs, and organizational constraints that no AI can fully grasp
In other words, the parts of software development that were always most human—creativity, judgment, communication, and contextual understanding—are now the parts that matter most.
This shift reminds me of how calculators ‘changed’ mathematics. Basic arithmetic became less important, while understanding what operations to apply and interpreting results became more crucial. Similarly, AI is pushing software development up the abstraction ladder, with enormous potential benefits for both individual productivity and the field as a whole.
The New Development Paradigm
After a month of living dangerously with AI coding tools, my perspective has entirely changed. What started as skeptical experimentation has evolved into a journey that ultimately led me to join the team at Kilo Code. Our vision is to build a superset of the best features from Cline and Roo Code inside VS Code. This aligned perfectly with what I was looking for—the best of both worlds in a tool that integrates into my existing workflow.
And for those of you who (unlike early LLMs) are good at math - you’ll note that I’m counting Kilo Code as my 10th tool 😉What drew me to Kilo Code wasn't just the technical approach, but I felt like the philosophy around "vibe engineering" rather than just "vibe coding" is really alive here. We're focused on creating tools that genuinely collaborate with developers rather than trying to replace them—exactly the partnership model I'd come to value through my experiments.
For those considering similar explorations into AI-assisted development, here's what I've learned:
Start with small, non-critical tasks to build trust and understanding of each tool's capabilities
Remain in the driver's seat - use AI as a co-pilot, not an autopilot (I guess GitHub is good at naming things!)
Diversify your AI toolbox - different tools excel at different tasks. But beware tool explosion (why Kilo Code was born)
Verify before trusting - especially for critical components or security-sensitive code. But really you should be “code reviewing” most to all of what AI writes
Invest time in learning to communicate effectively with AI tools - clear prompting is a skill worth developing
Don't suppress your skepticism - it's a valuable check against overreliance, but finding a healthy balance is key
What excites me most isn't what these tools can do today, but where this partnership model is heading. As developers learn to collaborate more effectively with AI and the tools themselves continue to evolve, we're entering an era where software development becomes more accessible, more powerful, and more creative than ever before.
The future isn't humans being replaced by AI developers—it's humans and AI engaging in vibe engineering together, creating software that neither could build alone. And I'm thrilled to be part of building that future.
What's your experience been with AI coding tools? Are you leveling up with assistants, experimenting with agents, or still coding the old-fashioned way? I'd love to hear which tools and workflows you've found most valuable. Join our Discord to share what you’ve learned!