Why My View on AI Coding Tools Changed

Table of Contents

The Journey Begins

A discussion on Reddit caught my attention and stayed in my thoughts for days. A developer remarked, “The longer you use Cursor, the more you realize its limitations.” This statement resonated with me, making me reflect on my journey with AI coding tools — from initial excitement to reality. I had to ask myself: Did I expect too much from these tools?

My start with AI coding tools began with YouTube tutorials. These videos presented an attractive idea: programming had become effortless, they claimed. No need to deal with complex programming concepts; simply input your ideas, and you’d receive complete solutions. As someone taking their first steps in programming, these promises were very appealing.

My first project was developing an HSK vocabulary learning website. The initial experience with Cursor seemed impressive — by describing my ideas, it generated a complete project framework, including both frontend and backend. However, as the project’s complexity grew, problems began to appear. When I tried to implement a JavaScript dialog feature, the AI not only failed to deliver the desired functionality but occasionally disrupted existing code. This pattern continued until the project stopped working.

Later, WindSurf became a new hope. Using my experience with Cursor, I quickly adapted to WindSurf’s workflow. It brought benefits — completing many tasks through natural conversation, even without additional plugins. Yet it had its challenges: in write mode, it would sometimes execute unauthorized operations that could affect existing code.

By incorporating familiar plugins (like foam, todo tree, prettier, markdownlint), my development work improved significantly. With WindSurf’s help, I started my second project — this Astro template-based blog. While the initial documentation suggested a smooth start, I soon discovered it needed more learning than WordPress’s plug-and-play approach.

Learning the Hard Way

The HSK vocabulary tool project clearly showed this learning process:

Initially, I tried the ambitious “big bang” approach:

"Create a flashcard system with difficulty levels, random questions, scoring system, and accuracy tracking"

While the generated code looked perfect at first glance, it had many hidden problems during implementation. The turning point came when I learned to break this down into smaller parts:

• Difficulty selection interface
• Basic flashcard component with front/back views
• Question randomization logic
• Scoring mechanism
• Progress tracking system

This step-by-step approach worked much better. The key lesson wasn’t about what AI could do, but how to work with it effectively.

Early Misconceptions

Like many others on Reddit, I started with basic misunderstandings about AI coding tools. A user’s direct question hit home: “Did you really think typing ‘Build me APP that makes me 2 million $$ per hour’ would work?” This comment showed a common mistake among beginners.

When I first started coding with AI, I thought it would be effortless. The reality soon emerged: learning to code isn’t about achieving perfection, but understanding the fundamentals. Just as speaking with foreigners requires basic grammar and vocabulary rather than fancy expressions, working with AI tools demands a grasp of basic programming logic and concepts.

This understanding led to a key insight: we need to communicate with AI in a clear, professional manner. Rather than vague requests like “I want a popup,” we should provide detailed specifications: “I need a modal component that displays on button click, contains a title, content, and close button, and clears form data on closing.” Such clarity improves AI’s ability to assist us.

Understanding the Tool’s Nature

These experiences shaped my view of AI coding tools. As one developer pointed out: “These tools are meant to make existing developers more efficient, not to write entire applications for you.” This observation helps explain a basic truth: AI coding tools are just that - tools, not magical solutions.

The comparison to Git helps explain this. Just as Git helps us manage code without writing it for us, AI tools offer their own benefits:

• Accelerating daily coding: Streamlining routine tasks through smart completions and code generation
• Providing references: Suggesting practical examples for unfamiliar APIs or patterns
• Assisting with diagnostics: Spotting potential issues before they become problems

This understanding changed how I use these tools. Like a craftsman who masters both their tools and their trade, a developer must understand both the potential and limitations of AI tools, while maintaining solid programming fundamentals.

Practical Guidelines

Armed with these insights, I developed a set of practical guidelines through hands-on experimentation and community wisdom. One piece of crucial advice stood out: “DO NOT MAKE CHANGES TO ANY OTHER CODE while also only asking it to do one thing at a time.” This seemingly simple principle changed my workflow completely.

Breaking Down Tasks

My refined approach now follows these core principles:

• Breaking down large tasks into smaller, manageable pieces
• Asking AI to handle one specific task at a time
• Keeping code changes within clear boundaries
• Testing each change before moving forward
• Using Git version control to track and manage changes

Version control has become a crucial part of my workflow. Just like writing code, when working with AI tools, each change should be committed separately. This approach offers several benefits:

• Safety net: If AI generates problematic code, we can easily revert to a working state
• Change tracking: Each commit represents a specific task or improvement
• Progress visibility: The commit history shows our learning journey and project evolution
• Experimentation freedom: We can try new AI suggestions without fear, knowing we can always go back

In my blog project, I follow this practical process:

1. Before any changes:

   • Discuss with AI about which files need to be modified
   • Understand the scope of changes to better track potential issues

2. During development:

   • If AI’s changes cause problems, immediately fix them locally:
     • Use “Discard Changes” in the code editor for affected files
     • Or use git reset --soft to undo commits while keeping changes
   • Keep testing until the feature works correctly
   • Only proceed when local build (npm run build and npm run dev) succeeds

3. After confirming everything works:

   • Commit with clear messages explaining the changes
   • Push to repository

This approach emphasizes solving issues locally before they become repository problems. While git revert and git rebase are available for repository fixes, it’s better to ensure everything works perfectly before pushing.

Starting from Scratch: A Sweet Spot

A Reddit comment captures this well: “In software engineering, the more complex a project gets, the harder it becomes to maintain/update/fix. I guess Cursor struggles just like the rest of us.” AI coding tools excel at helping us go from -1 to 0 (bringing ideas to life), but this initial success can be misleading.

My first project, the HSK vocabulary tool, clearly showed this pitfall. While AI helped me quickly build a working prototype, I soon found myself stuck. Without basic technical understanding and maintenance skills, the project became harder to manage as I tried to add new features. What started as an exciting quick win turned into a frustrating roadblock.

My blog project, however, showed a better approach. Instead of starting from scratch, I began with a well-structured Astro blog template. With the lessons from my first project and a better understanding of both coding basics and AI tools, I could carefully customize the template to my needs. Adding personal features and making changes became much easier because I had both a good foundation to build upon and the knowledge to use AI help effectively. This experience led me to develop practical guidelines for working with AI tools, focusing on long-term success rather than quick wins.

Future Development

Building Knowledge

The foundation of effective AI tool usage lies in our own expertise. The parallel with language learning is clear - just as limited vocabulary constrains expression, limited programming knowledge restricts our ability to work with AI tools. When I committed to mastering JavaScript fundamentals, I discovered I could not only articulate my requirements more precisely but also evaluate AI-generated code with greater confidence.

As one Reddit user put it: “Better prompt = better result. So I would say… Skill issue.” This insight was eye-opening - rather than focusing on AI’s limitations, we should work on enhancing our technical capabilities. Even as AI grows more sophisticated, it requires our professional guidance to reach its full potential.

A New Partnership

Through this learning process, I’ve found an effective way to work with AI tools. They serve as capable assistants offering insights and support, while we retain control of the decisions and direction. Rather than viewing AI as a replacement for learning, I now appreciate it as a powerful complement to human expertise.

In the end, tools amplify our capabilities but don’t define them. As AI continues its rapid evolution, our most valuable skill becomes our ability to work effectively with these tools to achieve our creative goals.