My AI Coding Journey: Lessons From The Trenches

When I first started using ChatGPT for coding, it was truly hit-or-miss. About 50% success rate, to be honest. Sometimes it would recommend packages for my project and give me functional code that worked perfectly. Other times, it would completely hallucinate functions and capabilities those packages didn't have. It was trying to help, creating code to complete my request, but the capability simply wasn't supported.

After pointing out these hallucinations, ChatGPT would sheepishly admit the package didn't have those specific classes or methods. This early experience taught me an important lesson: AI can be powerful, but it requires a knowledgeable guide.

Where AI Truly Shines

Despite these early hiccups, I quickly discovered areas where AI excelled. It became my go-to tool for debugging. I could copy/paste code with errors to ChatGPT, and it would identify issues with remarkable speed and accuracy. One conversation over problematic code would take just five minutes and save me hours of tedious debugging.

Even more impressive was its ability to analyze entire classes. I'd copy/paste them in, and ChatGPT would return spot-on analysis of how the structure could be improved, handling edge cases that might cause errors, and recommending improvements for coding style and consistency.

I've since moved to using cursor. The productivity boost has been substantial. What previously took a month, I can now accomplish in two days. I've wrapped entire REST APIs into fully-functioning SDKs in just two days, including comprehensive tests – something that would have easily been a 3-4 week project before, not including any test code.

Debunking Common Misconceptions

Working with AI daily has helped me identify two fundamentally opposite misconceptions about AI coding that are both wrong.

First, many developers believe AI can't write good, solid code and will always hallucinate. They doubt it can be agentic – taking problems that require reflection and multiple steps and executing them successfully. I use AI this way every day, and it absolutely can handle complex, multi-step coding challenges.

Second, others view it as a panacea that will replace engineers and UI/UX staff completely. People with minimal coding experience think they can use AI to write entire applications, but that's not how it works. You need existing expertise to effectively leverage AI in coding and design work.

Treating AI As Your Junior Staff

The most effective approach is viewing AI as a very junior staff member who can complete small, limited-scope tasks much faster than humans – like having a team you need to almost micro-manage.

This perspective shift has transformed how I approach development. You must already be proficient in your field, break work down from big picture into manageable steps, give the AI ways to track progress, and then guide it through each step toward completion.

This "management" requirement has actually improved my own planning. Because I need to guide the AI effectively, I'm forced to be more thoughtful about project structure. AI helps create the outline quickly, but we start with a solid plan from soup to nuts.

Unexpected Benefits Beyond Code

The benefits extend far beyond just faster coding. I've had AI analyze entire repositories, find and fix edge-case errors, implement good coding practices, and write tests achieving 100% code coverage.

I've even had AI create entire projects from empty repositories to fully functional applications and libraries. For every functional piece of code it writes, it generates twice as much testing code – something I would often skimp on when working alone due to time constraints.

When AI creates code, I still maintain complete understanding since I'm already a proficient developer. Sometimes I need it to rewrite code to match my preferred style (like promise.then() chains instead of await for performance reasons). Once AI understands a specific pattern relevant to an area of code, it consistently gets it right going forward.

Learning From Frustrating Limitations

Not all AI coding tools are created equal. I tried Cursor when it first launched but found little difference between using it or just copy/pasting from ChatGPT, so I quickly abandoned it.

When Windsurf emerged, claiming true agentic development, I invested both money and weeks of effort – only to give up. One frustrating pattern emerged: it would recognize a problem (like a failing test), cycle through various unsuccessful solutions, then return to the initial state and repeat the process. Each cycle burned about 37 tokens (approximately $0.75), making it impractically expensive when it failed to solve problems.

Another common challenge was providing too much context. When AI has excessive context, it gets confused about the narrow functionality it's working on. Similarly, giving too many steps at once causes it to lose track or forget steps. In large projects, it sometimes forgets important overarching approaches.

I later revisited Cursor and found it had matured significantly, becoming a much more useful IDE. Through these experiences, I've developed an effective process that practically eliminates problems and maximizes efficiency.

My Framework for AI Coding Success

I operate by four core principles when working with AI for coding:

Principle 1: Always start with the broadest scope and narrow down. Begin with overall plans, goals, and technology choices before moving to specific implementations. Start with the application's basic framework and directory structure, then progress to common base classes and data structures, and finally to specific functionality. By establishing structure first, the AI knows where to place new code and already has testing frameworks to build upon.

Principle 2: Use detailed task lists in files the AI can access, and maintain a notes file where it records important decisions for later reference – like directory layouts, test writing conventions, or specific technology implementation preferences.

Principle 3: Focus on one thing at a time. While AI may eventually handle breaking down complex paragraphs into sequential tasks autonomously, we're not there yet.

Principle 4: Structure tasks in patterns. After establishing base classes and testing frameworks, list all endpoints and methods the class should have. Work closely with AI to correctly implement the first endpoint and associated tests, then use that as a template for subsequent implementations. As the Special Forces say: "Slow is smooth, smooth is fast, slow is fast." Investing time upfront to establish correct patterns pays off in accelerated development later.

The Future of Developer-AI Collaboration

Looking ahead, I see two major shifts in the developer-AI relationship.

First, AI will become increasingly specialized. Imagine components bundled in your IDE – when writing database code, a database-specific AI could examine your database and generate all necessary code. You could use natural language to have it create and modify database structures, automatically updating code to match. Another component might specialize in React with Material UI, creating pages, forms, and components by examining and replicating other websites. While Multimodal Capability Plugins (MCPs) represent a step in this direction, they're more like APIs for AI than AI themselves.

Second, AI will become more agentic, handling longer chains of logical steps with greater autonomy.

Together, these developments will bring the next generation of "no-code" solutions to the masses. A suite of specialized AI components, coupled with more agentic control systems, could let anyone describe an app using natural language and have it built without understanding the underlying code.

Evolving Beyond Traditional Development

Despite coding almost daily since getting my first computer, I no longer view myself primarily as a developer. My career has spanned many roles: server admin, infrastructure security, technical program manager, DevOps engineer, and startup specialist.

With AI, I've evolved into more of a renaissance engineer, focusing on top-level business operations while leveraging targeted code generation sprints to enable higher-value business outcomes.

This shift highlights which skills will become increasingly valuable: software design patterns are crucial, as AI can write almost any algorithm, but a good developer knows which approach is right for each situation.

Those with dual engineering-business focus will need to apply Lean principles like innovation accounting. AI enables us to build larger systems faster, potentially committing us to directions not yet validated by customers. It reminds me of the old joke about a couple driving on a long trip when the woman realizes they're lost. When she points this out, her husband responds: "Yes, we're lost, but we're making great time!"

As we navigate this new landscape, the key isn't just coding faster – it's ensuring we're building the right things. AI gives us tremendous acceleration, but direction still matters more than speed. By treating AI as a junior team member rather than a replacement or a gimmick, we can harness its potential while maintaining the human expertise that gives code its purpose and direction.