This is the story of my two-year journey with AI. It’s a story of skepticism, frustration, eurokea moments, and ultimately a fundamental shift in how I write code. If you’ve been hesitant to dive into AI or if your initial attempts with it were underwhelming, then this account of my own trial and error might be exactly what you need.
The Age of Skepticism
If you had told me two years ago that an AI would be my coding partner, I would have said you were crazy. Back then, I was working for a company with a strictly isolated network, making any internet-reliant tool a non-starter. But my reluctance ran deeper than just logistics. I was a firm believer in the human element of coding; my expertise was built on deep research skills, navigating Google and Stack Overflow to find proven solutions from real developers who had been in my shoes.
Honestly, I didn’t see the value. I felt AI was a passing fad or at least something that would take years to become a truly viable product. There was no need to learn it now; I’d get to it when I had to.
My First Copilot
My new job came with new opportunities, particularly the chance to work for an employer who was eager to experiment with AI.
As one of few non-SAP developers, I was handed a GitHub Copilot license.
The timing was perfect. I was right in the middle of a tough refactor, moving an old Angular site over to Vue, and the refactoring itself was taking the most time.
It was repetitive work, following the same pattern over and over again.
I would copy code and, depending on my motivation that day, try to do the right thing by renaming variables, comments, and error messages. But I didn't always follow through. The consequences of this laziness always came back to haunt me during frustrating debugging sessions.
Exhausted, I decided to give GitHub Copilot a shot.
I created a new file and as soon as I opened it, Copilot sprung into action. It felt like it was reading my mind, autocompleting the entire file with maximum precision. It even named all the symbols correctly based on the filename. A task that would have taken me a full day of tedious, error-prone work was done in an hour. The code was perfect.
The text was written exactly as I would have envisioned. I recognized an opportunity to delegate the more routine tasks, which freed me up to concentrate on higher-level priorities.
However as I moved from repetitive work to creating new features, Copilot started getting in my way. I love the process of writing new code: experimenting, testing it, and refactoring it until it looks and feels right. It’s an iterative process born from the belief that I never truly know what the final result should look like until I’ve written it at least once.
GitHub Copilot was one eager assistant. I’d write a function signature, and it would immediately suggest a full implementation. But I didn't want suggestions then. It was disturbing my thought process and turning the exploratory phase of development into a nightmare.
The decision to quit was an unintentional but welcome one. In the whirlwind of setting up a new computer, the Copilot extension was simply forgotten. A full week passed before this oversight was even noticed. The realization, when it came, brought a sense of relief and the extension was intentionally left uninstalled, a decision never looked back upon.
A Push Back into the Future
The company hired a new CTO, an ex-Microsoft tech-lead who was adamant that AI was the future. He insisted that our dev teams embrace it, starting with GitHub Copilot.
Most of my team was now using JetBrains IDEs. I installed the Copilot plugin in Rider and WebStorm, and the experience was lackluster to say the least. It was clearly a second-class experience compared to the VS Code integration. The chat input was a single line with no ability to press enter and overly eager completions were back to annoy me. I disabled it again.
Although I was relieved to be free of the intrusive completions, I quickly found that I missed chatting with my AI companion every now and then. This led me to embrace other AI tools in my workflow. I began using ChatGPT for general coding tasks (while painstakingly sanitizing my inputs) and Claude for more specific ABAP and design-related questions. For research, Perplexity was a revelation; it cited its sources, which allowed me to verify its claims and, over time, build trust in its results.
Forced Immersion
The CTO was adamant: I was to start using Copilot, and he had a friend from his old team ready to coach me. Our experiment involved a deep dive into AI-driven development, with a complete reliance on VS Code and Visual Studio. While the AI experience itself was an improvement, any task requiring manual coding, debugging, or fixing became a frustratingly slow process. The fluency and efficiency of the familiar JetBrains environment were deeply missed. This led to a significant realization: while failing to adopt AI would mean being left behind, AI alone wasn't a strong enough incentive to abandon a preferred and highly productive development environment.
The search for a middle ground led to the JetBrains AI Assistant, which proved to be the perfect solution. The chat experience was excellent, less disruptive, and readily available when needed. For certain complex tasks, a brief switch to VS Code for Copilot Edits was necessary, but it quickly became clear that a dual-IDE workflow was not a sustainable long-term strategy.
Glimpses of the Future
Then, what I can only call the "agentic" era began to dawn. The buzz around tools like Cursor was deafening. The way people described it sounded as if its users were conducting symphonies, while the rest of us were still struggling to play scales.
The prospect of returning to a VS Code-based editor was met with both intrigue and hesitation. One day, while browsing the JetBrains blog, a particular post stood out: "Meet Junie: Your Coding Agent by JetBrains." An application for the Early Access Program was submitted and then promptly forgotten.
The arrival of the invitation in the inbox, however, changed things. Upon joining, five hours of sleep were immediately lost to a deep state of what is now referred to as "vibe coding." Junie was prompted to create a full-stack Tic-Tac-Toe application with Flask, a task it accomplished effortlessly. The following four and a half hours were a miserable failure in attempting to implement a "shareable link" feature.
Finally, the endeavor was abandoned with the decision to add the final part manually. That's when a feeling of paralysis set in. There was absolutely no idea where to begin. The entire application had been developed using prompts. Knowledge of the codebase was nonexistent. It felt like attempting to patch an obscure, ancient piece of software. Phenomenal speed had been achieved, but at the complete cost of control and understanding.
From Coder to Architect
The pivotal shift was finding my place in the Junie Discord, a thriving ecosystem where developers shared tips, provided actionable feedback, and saw their contributions integrated into new EAP builds within days
A major "aha!" moment came when the community discovered a new workflow: instead of asking Junie to write code directly, you instructed it to write its plan to a Markdown file.
This changed everything. My new development flow became:
- Plan: Ask Junie to create a detailed plan...
- Reason: Read through the plan...
- Refine: Edit the plan myself...
- Execute: Feed the final, human-approved master plan...
The result was magic. Junie would execute the plan, staying on track and producing high-quality, maintainable code that I already understood at an architectural level. This flow gave me speed, confidence, and control.
A month later, a network issue temporarily locked me out of the EAP. My reaction surprised me: I chose to take a break rather than work without it. The thought of reverting to my previous methods felt genuinely counterproductive. It's a question of effectiveness; once you've experienced a better way, the old way feels broken. It’s like trying to code after your It's like choosing to navigate with a paper map after your GPS has shown you a better way. You can still reach your destination, but you’re deliberately ignoring the efficiency and real-time advantages you've come to rely on.
Junie was no longer just an assistant; it was an indispensable and genuinely enjoyable part of my workflow.
Many Paths to Tread
It's natural to be skeptical of new technologies like AI, and my own early attempts were far from perfect. However, I learned that the real growth comes from pushing through that initial doubt and the frustration of early setbacks. By persevering I discovered new tools and methods that have fundamentally propelled my work forward. The key isn't to fight a fast-moving world, but to conquer our own hesitation to gain a significant advantage.
I believe AI coding tools are like IDEs. Everyone will have their preference, and there is no single right answer. The important thing is that you find your answer.
Now I'm taking my next step and embarking on a new journey: developing my own AI products and further exploring the new AI Frontier. I'm excited to share that story with you as it unfolds.
Top comments (0)