Yesterday I decided to go all-in on Claude Code. My bank account is $100 lighter today. Was it worth it? Well, that depends on what you're trying to do.

I managed to get Claude working on two different projects at the same time - which seemed impressive at first until I watched my credits drain faster than a bathtub with no plug. But hey, that's the price of innovation, right?

I spent several hours putting this tool through its paces, and I've got some pretty strong opinions already. Let's break down where Claude Code shines and where it falls completely flat.

What Is Claude Code?

For those who haven't tried it yet, Claude Code is Anthropic's entry into the AI code assistant space. It's designed to help developers with various coding tasks - from writing and refactoring code to explaining complex functions. Think GitHub Copilot or similar tools, but with Claude's reasoning capabilities behind it.

The pricing is credit-based, and as I quickly discovered, those credits can evaporate rapidly when you're running multiple projects. But more on that later.

The Good: Where Claude Code Actually Delivers

Let's start with what impressed me because there were definitely some bright spots in my $100 experiment.

Project Restructuring: A Genuine Time-Saver

I had a messy codebase that needed serious organization. Claude Code actually understood the architecture issues and proposed sensible restructuring. It didn't just move files around - it had opinions about proper component hierarchy, module boundaries, and how to better separate concerns.

In one case, it identified three services that should have been isolated modules and sketched out how to refactor them properly. This would have taken me hours of planning on my own. Claude did it in minutes while explaining its reasoning.

It was like having a senior architect looking over my shoulder, but one that doesn't make you feel stupid for your questionable design decisions from six months ago.

Unit Test Generation: Surprisingly Thorough

This is where Claude Code genuinely saved me time. It generated comprehensive test suites for functions that had zero test coverage.

What impressed me:

• It understood edge cases I hadn't considered
• Tests covered both happy paths and failure scenarios
• It matched my existing test style perfectly
• The tests actually ran with minimal tweaking

I pointed it at a particularly complex authentication service, and it came back with a test suite that covered every branch condition. It even explained its testing strategy before implementing it. For a codebase with poor test coverage, this feature alone might be worth the cost.

Zombie Code Hunter: Digital Marie Kondo

We all have dead code lurking in our projects - functions that were superseded months ago but nobody had the courage to delete. Claude Code is merciless with this cruft.

It identified:

• Unused helper functions
• Dead code paths that would never execute
• Duplicate functionality across modules
• Imported packages that weren't actually used

In one project, it found nearly 2,000 lines that could be safely removed. That's not just cleaner code - it's a performance improvement and maintenance burden lifted. The tool gave me the confidence to actually delete this code rather than just comment it out "just in case."

The Bad: Where Claude Code Falls Flat

Now for the painful part. Despite burning through $100, there were some serious limitations that left me frustrated.

Functional Programming: An Absolute Disaster

If you're working with functional programming patterns, save your money. Claude Code struggled catastrophically with anything beyond the most basic map/filter operations.

I tried to get help with some moderately complex Redux selectors and compose functions. The results were laughable. It constantly tried to convert elegant functional patterns into imperative code with unnecessary variables and state mutations.

When I pushed it to preserve the functional style, it produced code that:

• Created unnecessary closures
• Missed the point of pure functions entirely
• Produced bizarre composition patterns that no human would write
• Failed to understand basic concepts like function currying

If your codebase leans heavily on functional paradigms, you'll spend more time correcting Claude than benefiting from it. This is clearly not its strength.

The Credit Burn Problem

Let's talk about that $100. The credit consumption is aggressive, especially when working with larger projects. Having two projects open simultaneously was probably a mistake on my part - the meters were running down twice as fast.

What eats credits fastest:

• Analyzing large codebases initially
• Generating complex refactoring plans
• Asking for multiple iterations on the same problem

The value proposition becomes questionable when you're paying this much for assistance that's hit-or-miss. I found myself constantly aware of the credit consumption, which affected how I used the tool. That's never a good user experience.

Is It Worth It?

After my $100 experiment, would I recommend Claude Code? It depends entirely on your specific needs.

If you're:

• Tackling a legacy codebase that needs cleanup
• Working on a project with poor test coverage
• Trying to modernize an old project structure

Then yes, Claude Code might be worth the investment. The time saved on these specific tasks could justify the cost.

But if you're:

• Working primarily with functional programming patterns
• On a tight budget for developer tools
• Expecting it to understand highly specialized or domain-specific code

Then you'll probably end up frustrated and lighter in the wallet without much to show for it.

Final Thoughts

Claude Code shows promise but has clear limitations. For specific use cases, it's a powerful ally. For others, it's an expensive disappointment. The key is understanding which category your project falls into before you start burning credits.

Would I use it again? Yes, but much more selectively. I'd focus it on specific refactoring tasks and test generation where it excels, rather than trying to make it a general-purpose coding companion.

And next time, I definitely won't have two project instances running simultaneously while I go make a sandwich. That's a rookie mistake that cost me about $25 in idle time alone. Lesson learned.