Three months ago I started using Claude Code — Anthropic's terminal-based AI coding assistant — on actual client work. Not toy projects, not experiments. Real production systems that process real data for real companies.

I was skeptical. I've tried GitHub Copilot, Cursor, various ChatGPT-based workflows. They all helped with boilerplate and autocomplete, but none fundamentally changed how I worked. Claude Code did.

Here's what happened, without the hype.

What it actually does well

Architecture conversations that save days

The biggest productivity gain isn't code generation — it's the planning phase. Before Claude Code, I'd spend 2-3 days designing a system architecture, reading docs, evaluating tradeoffs. Now I have a conversation. I describe the problem, the constraints, the existing codebase. Claude Code reads the files, understands the context, and proposes an approach.

It doesn't always get it right. But it gets to a solid starting point in 20 minutes instead of 2 days. I still review everything, push back on bad ideas, and make the final calls. But the iteration cycle is dramatically faster.

Last month we had to add a new document processing pipeline for a client. Old process: 3 days of architecture, 2 weeks of implementation, 1 week of testing. With Claude Code: 4 hours of architecture discussion (including reading the existing codebase and understanding constraints), 4 days of implementation, 3 days of testing. Same quality. Roughly 60% less calendar time.

Refactoring without fear

We had a client with a 1200-line React component that needed to be broken into smaller pieces. In the past, this kind of refactoring was a week-long project with high risk of introducing bugs. Claude Code read the entire file, understood the component structure, extracted 20 focused components, moved inline styles to CSS, and deduplicated repeated patterns. The whole thing built and worked on the first try.

I still reviewed every file. But instead of doing the tedious work myself and reviewing my own tired-eyes code at the end of the day, I reviewed fresh code with fresh eyes. The quality was better because the review process was better.

Integration code and boilerplate

Writing Express middleware, setting up API endpoints, configuring build tools, writing structured data markup — this is where Claude Code shines brightest. Not because the code is hard, but because it's the kind of work where human errors are most common. Forgetting a header, misconfiguring CORS, getting a JSON-LD schema slightly wrong. Claude Code doesn't make typos and it doesn't forget the edge cases it knows about.

Where it fails (and how we handle it)

It's confidently wrong about things it doesn't know

Claude Code will write code that looks correct but makes assumptions about your specific business logic that it can't possibly know. We had it generate a currency conversion function that silently rounded to 2 decimal places. For most use cases that's fine. For our client's financial reporting system, it needed to be 4 decimal places. The code passed all the tests we had, because our tests also assumed 2 decimal places.

The lesson: Claude Code is great at writing code that follows patterns. It can't know your domain-specific requirements unless you tell it explicitly. We now front-load every session with constraints and edge cases.

It over-engineers when you let it

Ask Claude Code to "add error handling" and it'll add error handling to things that don't need it. Ask it to "make this more robust" and it'll create abstractions you didn't ask for. The tendency toward thoroughness is a strength when writing code from scratch, but it becomes over-engineering when applied to existing codebases.

We learned to be very specific. Not "improve this function" but "add retry logic for the HTTP call on line 47, max 3 retries with exponential backoff, and log the failure if all retries fail."

It can't debug production issues

When something breaks at 2 AM and the logs show a cryptic error, Claude Code can help you understand the error message and suggest hypotheses. But it can't look at your monitoring dashboard, it can't correlate the error with the deployment that happened 30 minutes earlier, and it can't tell you that the real problem is that someone changed a database password.

Production debugging still requires human engineers who understand the system holistically. Claude Code is a tool, not a teammate.

How we actually use it day-to-day

Our workflow has settled into a pattern:

1. Planning sessions — We describe the project, constraints, and existing code. Claude Code proposes an architecture. We iterate on it. This replaces the "staring at a whiteboard for 3 hours" phase.

2. Implementation sprints — We implement features with Claude Code, working through the plan step by step. It writes the code, we review and adjust. For standard patterns (API routes, database queries, UI components), it's faster than writing from scratch. For novel business logic, it's about the same speed but with fewer silly bugs.

3. Review and refinement — Every piece of code gets human review. We've found that reviewing AI-written code is faster than reviewing human-written code, because it tends to be consistent in style and doesn't have the "I was tired when I wrote this" sections.

4. Testing — Claude Code writes good unit tests. It catches edge cases I might miss. But we still write integration tests ourselves, because those require understanding how the whole system fits together.

The economics

Here's the honest math for our team:

  • Before Claude Code: A typical client project (document processing system) took about 6 weeks from kickoff to production. Billable hours: ~240.
  • After Claude Code: Same type of project takes about 3.5 weeks. Billable hours: ~160.

That's roughly a 35% reduction in delivery time. Our clients pay less, we deliver faster, and the code quality is at least as good — often better because more time goes into review and less into typing.

The subscription cost is negligible compared to the billable hour savings. For us it was profitable from the first project.

What we tell our clients

We're transparent about it. We tell clients we use AI-assisted development tools, the same way a builder would tell you they use power tools instead of hand saws. The tool doesn't replace the carpenter — it makes the carpenter faster.

Some clients were initially concerned. After we showed them the code quality and the faster delivery timelines, none of them objected. They care about results, not about whether each line was typed by a human finger.

What I think this means for the industry

Claude Code (and tools like it) will accelerate the gap between good engineering teams and mediocre ones. A skilled developer with Claude Code can outpace a team of three average developers. But a bad developer with Claude Code will just produce bad code faster.

The craft of software engineering isn't going away. It's shifting from "how do I write this code" to "how do I design this system, review this code, and make the right tradeoffs." The boring parts get automated. The judgment parts get more important.

For our company, it means we can take on more projects with the same team, deliver faster, and spend more time on the parts that actually require human expertise — understanding the client's business, designing the right AI strategy, and making sure it works in production.

That's not a threat to our business. It's the best thing that's happened to it.