My Experience Building with Claude: The Good, The Bad, and The Reality

After spending considerable time building applications with Claude, I wanted to share my honest thoughts on what it’s like to develop with AI assistance. Here’s what I’ve learned from the trenches.

The Magic Moments

Rapid Prototyping Feels Like Wizardry

There’s something genuinely magical about having an idea and watching it take shape within an hour or two. The speed at which you can go from concept to working prototype is unlike anything I’ve experienced in traditional development. It’s the closest thing to thinking something into existence.

Error Resolution Without Diving into code

One of the most surprising benefits is how you can often resolve errors through conversation rather than debugging code line by line. Claude throws errors, sure, but you can usually fix them by describing what’s wrong rather than hunting through stack traces.

Exploring New Territory

I’m comfortable with the Go ecosystem but have always struggled with UI frameworks. Claude let me experiment with Svelte while staying in familiar backend territory. This combination of known and unknown technologies created a surprisingly enjoyable coding experience where I could focus on learning without getting bogged down in setup.

Pivoting Ideas at Lightning Speed

I built a CLI tool to manage configuration changes and comparisons across multiple Keycloak servers. Midway through, I realized a web UI would be more practical. Instead of starting over, I simply asked Claude to convert the CLI logic into a web server. After a few iterations, it was up and running. Within hours, I had completely changed the direction of my project and could assess whether this new approach was better. This kind of rapid pivoting is invaluable for exploration and validation.

The Reality Check

###* The Joy of Coding Gets Lost* After using Claude for too many small projects, I felt something empty—almost sad. I realized it had taken away the fun of thinking in code. I didn’t have the drive to write anymore; I just let Claude do the magic. I had to consciously resist and go back to my old way of working, but this time including Claude as a reviewer. I’d ask it to comment on things it thought could be better in my codebase. This felt like a great balance where I still controlled everything but got the best of Claude’s insights.

Don’t Let AI Set Your Foundation

You can’t let Claude or any agent do the scaffolding for you and set the skeleton out of the box. You should know exactly what your dependencies are and how the flow goes from method calls to helper functions. Use AI to complete features within the boundaries of a project that YOU defined.

Code Volume Becomes Unmanageable

The sheer amount of code these tools generate is staggering. After implementing just two features, you’ll find yourself drowning in files you didn’t write and can’t fully comprehend. At that point, you’re completely dependent on prompting rather than understanding, which is a precarious position for any developer.

The Excitement Fades

It started with excitement, then turned to frustration with too many prompts, and finally left me with no motivation to use it for any complete feature. Over time, I didn’t like looking at features that it wrote instead of me—features I don’t understand at all.

Success Bias is Real

You become addicted to the happy path. While you can ask Claude to handle edge cases and write tests, your satisfaction is primarily based on seeing things work visually. This creates blind spots where you’re never quite sure what scenarios aren’t covered. Even when Claude writes tests, you’re still relying on execution rather than true understanding.

###Prompt Fatigue is Exhausting The irony is that you end up typing more and thinking less. The constant back-and-forth of refining prompts becomes mentally draining. It’s not uncommon to hit Claude’s token limits during a single session, and the iterative process can feel more tedious than just writing the code yourself.

Enterprise Reality

Let’s be honest about organizational dynamics. No company is going to trust an AI agent to write entire codebases, nor should they. Claude and similar tools will remain in the same category as IDEs and build tools—workflow enhancers, not replacements for developer judgment and expertise. One developer does not equal Claude, despite what the hype might suggest.

I could be wrong about this trajectory, and I’d love to be proven wrong over time. But I don’t see it happening anytime soon.

How I’m Using Claude Going Forward

I’m keeping my subscription, but with focused use cases:

Scaffolding and Boilerplate

Perfect for setting up project structure, configuration files, and repetitive setup tasks that nobody enjoys writing by hand.

Code Review Partner

Having a second pair of eyes (even AI ones) to review logic and catch potential issues has proven valuable.

Contained Features

Small, well-defined features where I can maintain complete mental models work well. Think logging setup, simple utilities, or straightforward CRUD operations.

Idea Creation and Validation

The speed of bringing ideas to life remains unmatched for proof-of-concept work and exploring possibilities. AI acts as a thought partner that challenges your assumptions, identifies potential flaws, and helps you see blind spots you might miss. This back-and-forth helps validate ideas faster and deepens your understanding—you learn by having to defend and refine your thinking. It’s not just about building quickly; it’s about making sure you’re building the right thing.

Final Thoughts

Claude and similar tools are powerful—they’ve genuinely changed how I approach certain aspects of development. The rapid prototyping capabilities are revolutionary, and there’s real value in having an AI pair programmer for specific tasks.

However, it’s not the silver bullet that replaces traditional development skills. Understanding your codebase, thinking through edge cases, and maintaining architectural vision remain fundamentally human responsibilities. The tools enhance our capabilities but don’t replace the need for deep technical thinking.

The key is finding the right balance—leveraging AI for what it does best while maintaining the developer skills and judgment that only come with experience and understanding.