AI Code Generation Tools: How I Actually Use Them in Production

My Actual Daily Workflow, Honestly

I want to be specific rather than generic here, because the "AI is transforming software development" framing that dominates most writing about this topic obscures what it actually means in practice for a working developer. So let me tell you specifically what I use and how.

I build AI-native applications and enterprise software from my practice in Dallas. My primary tools are Claude Code for agentic development tasks, Cursor for editor-level code generation and refactoring, and direct Anthropic SDK integration in my applications. I've also used GitHub Copilot extensively and evaluated several other tools.

Here's what these tools actually do well and what they don't.

Claude Code: The Agentic Tier

Claude Code is where I do the most cognitively complex AI-assisted development work. The difference between Claude Code and a simpler code completion tool is the difference between having an assistant who can read your entire codebase, understand what you're trying to do, and execute multi-step tasks versus having an intelligent autocomplete.

What it's genuinely good for in my workflow:

Large-scale refactoring tasks. When I need to rename a pattern throughout a codebase, migrate from one API to another, or restructure a module while preserving behavior, Claude Code handles this better than manual editing and faster than scripted approaches. It understands context — it doesn't just do find-and-replace, it understands what the code means and makes changes that preserve intent.

Implementing well-specified features. If I write a clear specification for a feature — here's what it needs to do, here's the data model, here are the constraints — Claude Code can implement a complete first draft that I then review and refine. The output quality is high enough that I'm typically editing and improving rather than rewriting.

Test generation. Writing comprehensive tests is tedious and Claude Code does it well. Given a function or module, it generates edge-case-aware test suites that I would have taken significantly longer to write manually. The tests aren't always complete — I add cases it missed — but they're a strong starting point.

Where I still do the work myself:

High-stakes architectural decisions. I don't delegate decisions about system boundaries, data model design, or API contracts to AI tools. These require contextual judgment about my client's business requirements, future flexibility, and operational constraints that Claude Code doesn't have.

Security-sensitive code. I write and personally review all authentication logic, authorization checks, cryptographic operations, and data handling code. I use AI tools for review (an additional pass catches patterns I might miss) but not for initial implementation of security-critical components.

Cursor: The Editor-Level Tool

Cursor is where I spend most of my active coding time. It's a VS Code fork with deep AI integration — code completion, inline generation, codebase-aware chat, automatic context from the files you're working in.

What works well:

The codebase-aware chat is genuinely useful. When I'm in a complex codebase and need to understand how something works, I can ask Cursor and it retrieves relevant code context automatically. This is faster than grepping and faster than reading unfamiliar code linearly.

Inline generation for boilerplate-heavy code. TypeScript interfaces, Prisma schema definitions, API route handlers with standard patterns — Cursor generates these quickly and correctly when I describe what I need.

Function completion with context. Unlike GitHub Copilot's line-by-line completion, Cursor's completions are context-aware in a way that produces more useful suggestions for complex function implementations.

Where I use it cautiously:

When working in unfamiliar territory, Cursor can confidently generate code that is subtly wrong — it looks right, compiles, but implements behavior that's not quite what's needed. This is the hardest failure mode to catch because it doesn't produce errors, just incorrect behavior. The remedy is the same as for any code you didn't write yourself: understand what it generated before accepting it.

GitHub Copilot: Still Relevant in a Specific Niche

I've used GitHub Copilot since early beta and still use it in specific scenarios. In 2026 it's not my primary tool — it's been outcompeted on the features that matter most to me. But it's still excellent at:

Fast, repetitive code patterns. When I'm writing the tenth variation of a similar function, Copilot often completes it correctly in one shot. The muscle memory for accepting or rejecting Copilot suggestions is well-trained at this point.

Environments where I don't want to switch context. For quick edits in a file where I'm already in a flow state and just need completion assistance, Copilot's unobtrusive suggestions work well.

It's less useful for the kinds of complex, context-rich tasks where Claude Code and Cursor's deeper integrations shine.

The Productivity Reality: What These Tools Change

Let me be specific about the productivity impact, because both exaggerated claims and dismissiveness are common. Here's what I actually observe:

Boilerplate and repetitive code: Effectively eliminated from my time budget. Code that's structurally predictable from its context — CRUD operations, validation schemas, test setup code, type definitions — gets generated rather than typed.

Research and pattern lookup: Significantly reduced. Questions that would have required me to consult documentation or StackOverflow I now answer conversationally with Claude. The quality of answers is high enough that I trust the response and verify when it matters.

First-draft implementation time: Meaningfully faster. I'd estimate my first-draft implementation time for well-specified features is 40-60% of what it was before these tools. The remaining time goes into review, refinement, and addressing the things the AI missed.

Debugging complex issues: Marginally impacted. AI tools are helpful for debugging familiar error patterns. For novel, complex bugs that require deep system understanding, I don't find significant speedup from AI assistance. This is still human-intensive work.

Architectural thinking: Unchanged. The time I spend thinking about system design, trade-offs, and architecture is not meaningfully reduced by AI tools. That work is still mine.

The Skills That Still Matter Enormously

One concern I hear from developers is whether AI code generation tools are making software development skills obsolete. I'll be direct: the skills that determine software development quality have not been made obsolete.

Understanding what correct looks like is more important than ever because you're reviewing and approving AI-generated code rather than writing every line. You need to understand the code you're accepting, not just whether it compiles.

System design and architecture thinking is undiminished. These tools don't tell you what to build, how to structure it, where to put the boundaries, or how to make it maintainable. That judgment is still entirely human.

Security and performance thinking hasn't been automated. AI tools generate secure code more often than novice developers do, but they also generate code with subtle vulnerabilities regularly. You need the expertise to catch this.

What's changed is the ratio of thinking-to-typing in the work. More of my time goes into specification, review, architectural thinking, and client communication. Less goes into typing code I already know how to write. That's a good shift.

If you're planning a software project and want to work with someone who uses these tools effectively — not as a replacement for engineering judgment but as a multiplier on it — schedule time with me at Calendly. I'd be glad to discuss what your project needs and how I'd approach it.