My AI Stack in 2026: What I Actually Use

Every week there's a new AI tool promising to change everything. Most of them don't survive past the hype cycle. After months of trying, discarding, and refining, here's what actually stuck in my workflow — and why.

The Core: Claude Code

Claude Code is the backbone of my development workflow. Not as an autocomplete engine, but as a genuine collaborator that can reason about architecture, write implementation plans, and execute multi-file changes with context.

What makes it different from other AI coding tools:

• It reads the whole codebase. Not just the file you're looking at — it understands how pieces connect. When I ask it to add a feature, it knows where the related utilities live, what patterns the project already uses, and what tests need updating.
• Planning before coding. The best results come from letting Claude Code think through the approach before touching any files. I'll describe what I want, it proposes an architecture, we iterate, and then it executes.
• Honest about limitations. When Claude Code isn't sure about something, it says so. That matters more than you'd think — an AI that silently guesses wrong wastes more time than one that asks a clarifying question.

I use it for everything from scaffolding new projects to debugging production issues. The blog you're reading was built almost entirely with Claude Code — from the Astro setup to the Keystatic CMS configuration.

The Editor: Cursor

Cursor is my IDE. It's VS Code at its core, which means all my extensions and keybindings carry over, but with AI capabilities baked into the editing experience.

Where Cursor shines for me:

• Inline edits. Select a block of code, describe what you want changed, and it rewrites it in place. Great for refactoring — "make this function handle the error case" or "convert this to use the new API."
• Tab completion that understands context. It doesn't just complete the current line — it often predicts the next 3-4 lines based on the pattern you've established.
• Chat with codebase context. Similar to Claude Code but integrated right into the editor. I use this for quick questions — "what does this hook do?" or "where is this type defined?"

Cursor and Claude Code complement each other well. Cursor handles the micro-level — line-by-line edits, quick completions, small refactors. Claude Code handles the macro-level — multi-file features, architectural decisions, complex debugging sessions.

What I've Tried and Dropped

Being honest about what didn't stick:

• GitHub Copilot. Good autocomplete, but Cursor's is better. I don't need both.
• ChatGPT for coding. The copy-paste loop between a chat window and the editor adds friction that Claude Code and Cursor eliminate entirely.
• Various "AI coding agents." Most of them produce code that technically works but doesn't fit the project. They optimize for making something run, not for making something maintainable.

How the Pieces Fit Together

My typical workflow looks like this:

1. Start in Claude Code for anything substantial — new features, bug investigations, refactors that touch multiple files
2. Work in Cursor for the hands-on editing — tweaking implementations, writing quick utilities, exploring code
3. Back to Claude Code for review and testing — running the test suite, checking for issues, getting a second opinion on the approach

It's not about using AI for everything. It's about using the right tool for the right scale of work. Claude Code for the 30,000-foot view, Cursor for the ground-level details.

The Honest Assessment

AI tools haven't made me a 10x developer. They've made me maybe a 2-3x developer who ships more confidently. The biggest gains aren't speed — they're in reducing the mental overhead of holding an entire system in my head.

When I can offload "remember every file that needs to change for this feature" to Claude Code, I can spend my energy on the decisions that actually matter: what to build, how the UX should feel, whether this feature is even worth shipping.

That's the real value. Not writing code faster — thinking more clearly about what code to write.