As an early adopter AI seemed to slow me down in languages I had been programming in for over a decade. However, when I needed to pick up a new language for a project it felt magical, up until it didn’t. Then it just felt like another tool.
A Programmers Journey Link to heading
I am a technophile and have been programming for over three decades, professionally for over two decades. I remember a time when I wrote every line of code by hand, and spent hours tracking down small bugs in code. So when AI coding tools like GitHub CoPilot first emerged, I was both excited and apprehensive. I worried that relying heavily on AI might erode the programming skills I had painstakingly built over decades. Would I start forgetting simple syntax or commands that had become second nature? Could my fluency with various libraries gradually diminish, replaced by a dependency on automated suggestions? Perhaps most troubling, I dreaded becoming one of those developers who struggles to code without AI auto-complete, losing the sharp instincts and reflexes honed through years of hands-on coding. These anxieties were genuine, rooted in a career built on meticulous, manual craftsmanship.
CoPilot: A Helpful but Imperfect Apprentice Link to heading
The first AI coding tool I really dove into was GitHub CoPilot. I tried it when I was deep in a codebase I had been hand-crafting for over 8 years written entirely in JavaScript with Node.js. It felt out of place and like it got in my way more than it helped. However, when I switched to a new company and had to pick up C# for an exciting new AI project, using CoPilot felt like magic at times—whole blocks of code would appear as if it read my mind. It was as if I had an apprentice sitting next to me, one who could instantly recall documentation and type at 200 WPM. This boost in speed was real; I started implementing features faster than before. But it wasn’t all smooth sailing. Often, the code CoPilot suggested was syntactically correct yet subtly wrong or suboptimal. I remember writing a function to parse dates and CoPilot confidently autocompleted it, but on testing I found it ignored a critical timezone conversion. In another case, it suggested using an outdated API that our project had long replaced. These were obvious mistakes that any experienced programmer on my team would catch. I quickly found that while it didn’t make the same type of mistakes I did, it made ones I would never make, and fixing them sometimes took longer than writing the code from scratch would have!
I soon discovered that CoPilot’s suggestions required even more oversight than I would typically give a junior developer’s code during a code review. The tool would save me keystrokes, sure, but I had to remain vigilant.
CoPilot would happily produce a solution, but I had to spend time checking edge cases, fixing style issues, and ensuring it fit our architecture. It reinforced a crucial point: AI can assist with writing code, but understanding and owning that code is still squarely on my shoulders.
I also noticed another issue, skill atrophy. I forced myself to write the “important” parts of the code. Still, I noticed a change: I wasn’t memorizing function names as much, and I’d occasionally pause, wondering “what was that parameter order again?” This was exactly what I had feared.
I was still measuring my worth as a programmer at having memorized a specific language syntax.
Chat Interfaces Link to heading
Eventually, I uninstalled CoPilot entirely and turned to using chat-based AI assistants like ChatGPT and Claude directly via web interfaces. Unlike CoPilot’s instant code completions or Cursor’s tightly scoped refactoring commands, these chat interfaces provided a conversational and iterative environment. Here, I could discuss my coding problems, ask detailed questions, and even have these assistants generate code snippets that I would manually type myself. This interaction felt significantly more engaging—it was closer to pair programming with an insightful partner who didn’t just give me the answer but walked me through the thought process. By actively typing out the suggested solutions myself, I maintained deeper engagement with the code, reinforcing both my understanding and memory of programming concepts. I have heard some people say that developers doing it this way are out of date and not using AI to its fullest. However, I believe that the people who feel they need this in their editor the most are those who have skill issues. Yes it may type it out faster than I can, but I spend twice as long debugging it so is it really saving me any time?
But boilerplate… why haven’t you already used other methods to automate your boilerplate?
However, that is not the end of my AI journey.
Cursor: Taking the Driver’s Seat with AI Link to heading
When I heard about IDEs with AI built in I was skeptical. I had watched the train wreck Devin had been. The next one I tried was Cursor, an AI-enhanced IDE that promised deeper integration into the development workflow. Unlike CoPilot (which is an extension), Cursor is a full-blown code editor with AI built in. This intrigued me—I wondered if a tool designed from the ground up for AI assistance would change the game.
Using Cursor felt like stepping into a more advanced workshop with new power tools. It had features like an “Agent Mode” for handling multi-step refactors and a chat interface where I could ask for explanations or tweaks in plain English. I remember testing a refactor: I asked Cursor to rename a variable across the project and update related code. It spun for a moment and then presented a diff of changes spanning multiple files. It wasn’t perfect on the first go (it missed an update in a README, amusingly), but it was impressive to see an AI-driven global refactor in action.
While Cursor offered powerful and precise features, its rigid, literal-minded nature meant I had to spell out every step explicitly—turning it into a highly capable but inflexible assistant that ultimately slowed me down and led me back to chat-based AI tools better suited to my iterative and exploratory workflow.
Cursor and CoPilot agent also both suffered a fatal flaw… their autocomplete did not make sure all issues were resolved before completing… hence…
WindSurf with Sonnet 3.7: A True Force Multiplier Link to heading
The real turning point in my AI journey came when I started using WindSurf with Sonnet 3.7. This setup combined another AI-centric editor (WindSurf) with a powerful AI model (codenamed Sonnet 3.7). I was curious due to buzz in the developer community – some folks claimed this combo was where the true future of AI-assisted coding was headed. After my experiences with CoPilot and Cursor, I approached WindSurf with cautious optimism and a healthy dose of skepticism.
My first experience with WindSurf immediately felt unique and genuinely promising. Unlike my previous AI tool encounters, WindSurf displayed a surprising level of contextual awareness. It seemed to intuitively grasp the structure and requirements of my entire project, seamlessly recalling code structures, dependencies, and recent changes across different files and coding sessions. This broader, project-level awareness dramatically reduced the tedious task of constantly reminding the AI about project-specific details. I later discovered this impressive functionality was due to WindSurf’s Cascade Memory System, an innovative approach that maintained context not just within a single file or session but persistently throughout my entire workflow. This was a significant leap forward—it meant I could rely more on the AI’s suggestions and spend less time restating foundational concepts or correcting obvious contextual misunderstandings.
The Sonnet 3.7 model powering WindSurf also introduced an interesting dynamic. Its style of assisting felt more iterative and thoughtful. Rather than dumping a full solution instantly, it sometimes took a couple of smaller steps to get there.
In hindsight, this made sense. The AI was thinking out loud, so to speak, and that allowed it to align more with my intent before finalizing code. There were moments it truly impressed me. For example, I asked it to implement a function across several microservice repos (a tall order). WindSurf generated not only the function code but also suggested updates in the deployment config and documentation file, which I had completely forgotten to update! It was like working with someone who not only writes code but also reminds you of the ancillary tasks around that code. Neither CoPilot nor Cursor had given me that level of holistic support.
Of course, WindSurf with Sonnet 3.7 was not perfect either. It would occasionally make a poor structural decision, like suggesting a global variable for something that clearly needed to be a function parameter. And it loves to insert overly verbose comments at times, explaining the code it just wrote (some of my teammates had a laugh at those AI-written comments). When such things happened, it only underscored the importance of my oversight. I had to step in, refactor or tweak those bits, and sometimes gently prompt the AI to try a different approach. Interestingly, I didn’t find these moments frustrating; I found them empowering. Why? Because they reminded me that I am the senior engineer in this collaboration. The AI might be fast and knowledgeable, but it doesn’t truly understand the project’s goals or the nuances of good software design. That’s my job. WindSurf became, in effect, a force multiplier for me. It amplified my productivity (I could get more done, faster) and it amplified the importance of my expertise (my judgment was needed more than ever to steer the ship).
By the time I settled into a groove with WindSurf, my initial worries had largely dissipated. I didn’t feel like I was losing my skills; I felt like I was sharpening them in new ways. I still encountered new libraries and wrote code without AI to keep myself fresh, but I no longer felt guilty using the AI tools. In fact, I began to embrace them fully, with the recognition that they make me better only when I bring my own knowledge to the table.
I found myself reviewing and thinking in broader scopes, rather than getting lost in the weeds of syntax. My value as an engineer became even more about architectural thinking, code review, and decision-making, which is exactly what it should be.
The Blacksmith’s Auto Hammer: Embracing AI with Expertise Link to heading
I often think of AI tools in my career as a “blacksmith’s auto-hammer” in my workshop. Just as an inexperienced smith could wreak havoc with a power hammer, an unskilled programmer can create a mess by blindly following AI-generated code. I nearly fell into that trap early on, when I was apprehensive and then overly trusting. But with time, I learned to wield these tools with skill. Now, the power hammer is an extension of my own craftsmanship. I can craft more, craft faster, and even attempt more ambitious projects than before. Yet every strike of that auto-hammer is guided by my trained hand. AI is no different. In untrained hands, it can make a mess. But in the hands of a skilled blacksmith, it’s a force multiplier.
What I learned Link to heading
- AI doesn’t replace expertise - it magnifies it
- Use different tools for different jobs
- Don’t skip hands on coding - it keeps your edge sharp
- While you can use the AI to help you problem solve at the end of the day you are responsible for the code you ship.
Where I ended up Link to heading
I use three solutions when I code now.
When I’m doing my normal work I use NeoVim with no autocomplete plugins. This is my vibe coding.
Then while I’m debugging or have questions about code I will plug it into Claude.ai and integrate the GitHub repo in.
While I’m working on a POC, reviewing a legacy codebase, or working with a language or library I do not know (cough CGO) I use WindSurf.
Finally, when I’m discussing design and higher level concepts of code structure or generating ideas I use ChatGPT.com.
I remain excited in this new era of AI-assisted development. I know that by nurturing my own expertise and staying true to software engineering best practices, I can harness AI to build software more effectively than ever. The hammer has changed, but the blacksmith wielding it is still here, honing his craft with every swing.