How I Used Cursor + Claude Code to Ship Faster and Think Less About Boilerplate
A practical look at how combining Cursor's agentic IDE with Claude Code transformed my development workflow — from faster debugging to hands-free deployments.
There's a particular kind of developer frustration that doesn't show up in bug trackers. It's the friction of getting to the work — jumping between tabs to read docs, writing the same scaffolding for the fifth time, losing your train of thought while you grep for a function name you half-remember. The code itself is rarely the bottleneck. The overhead around it is.
Over the past several months, I've restructured my development workflow around two tools: Cursor as my primary IDE and Claude Code as my CLI agent. Together, they've eliminated most of that overhead. This post is an honest account of how I use them, what changed, and how you can set up something similar.
What an Agentic IDE Actually Is
Most developers have used AI autocomplete by now — GitHub Copilot, Tabnine, or similar. These tools are reactive: you type, they suggest the next token. Useful, but fundamentally limited to single-expression or single-line completions. You're still the one orchestrating every edit.
An agentic IDE is different in kind, not just degree. Instead of suggesting what comes next, it can:
- Understand your intent at the task level ("add pagination to this API route")
- Plan a sequence of edits across multiple files
- Run commands, read output, and adjust based on results
- Hold context about your entire codebase, not just the open file
The shift is from autocomplete to collaboration. You describe what you want done; the agent figures out the steps and executes them. You stay in the loop — reviewing, redirecting, approving — but you're no longer doing the mechanical work yourself.
Cursor: The IDE
Cursor is a fork of VS Code built around agentic AI from the ground up. It uses the same extension ecosystem and keybindings you already know, so the learning curve is mostly zero if you're coming from VS Code.
The feature that changed how I work is Composer (now called Agent mode). You open it with Cmd+I, describe a task in plain English, and Cursor plans and executes a sequence of file edits — creating files, modifying existing ones, refactoring across modules. It shows you a diff before applying anything, so you maintain full control.
A few things that make it genuinely useful rather than a demo toy:
Codebase indexing. Cursor indexes your entire repo and uses that context when generating edits. It doesn't just know the file you have open — it knows how your types flow, where your utilities live, what patterns you've established. This means suggestions are coherent with your existing code, not generic completions.
Inline chat with Cmd+K. Highlight a block of code, hit Cmd+K, and ask a targeted question or request a change. This is my go-to for understanding unfamiliar code, renaming with reasoning, or quickly refactoring a single function without involving the full agent.
Terminal awareness. When Composer runs a shell command and it fails, it reads the error output and tries to fix the problem. This feedback loop — write, run, observe, adjust — is what makes it feel like working with someone rather than just a smarter autocomplete.
Claude Code: The CLI Agent
Claude Code is Anthropic's official CLI tool. You run it from your terminal in any project directory and have a conversation with an agent that has access to your file system, git history, and shell.
Where Cursor lives inside your editor, Claude Code operates at the level of your project as a whole. I use it for tasks that don't fit neatly inside a single editing session:
- Large-scale refactors that touch dozens of files
- Writing and editing content (like this blog post)
- Answering architectural questions with actual code evidence ("what's the data flow between these two modules?")
- Automating setup tasks — generating config files, running migrations, scaffolding new feature directories
It also integrates directly into VS Code and JetBrains as an extension, so you can access it without leaving your editor if you prefer. But the terminal interface is where it shines for longer, multi-step tasks.
How They Work Together
I think of the two tools as operating at different granularities:
| Cursor | Claude Code | |
|---|---|---|
| Primary surface | Editor (files, diffs) | Terminal (whole project) |
| Best for | In-flow edits, debugging, single feature work | Long-horizon tasks, refactors, content, git ops |
| Trigger | Opening a file, working on a specific problem | Stepping back from the editor |
| Interaction style | Short, targeted prompts | Conversational, multi-turn |
In practice, most of a working day is in Cursor. Claude Code comes out when I need to zoom out — when the task is bigger than a feature, or when I want to work through something without having a specific file open.
They share the same underlying model (Claude), which means context and style stay consistent. If I've been doing something in Cursor and want to continue the thought in a Claude Code session, the handoff is natural.
Real-World Examples
Debugging a production layout regression
A CSS change I made broke the mobile layout on a page I hadn't visually tested. The symptom was obvious but the cause wasn't. I opened Cursor's inline chat, highlighted the affected component, and asked it to explain why the flex layout might collapse at small viewports. It identified a min-width conflict two levels up in a parent component I hadn't looked at, showed me the fix, and applied it. Total time: under four minutes. Without AI assistance, I'd have been in DevTools for twenty.
Scaffolding a new feature end-to-end
Adding a blog section to this portfolio meant: a new route, a data-fetching layer, a listing component, a detail page, MDX rendering support, and metadata generation for SEO. I opened Cursor Composer, described the full feature, and watched it create the file tree, wire up the data layer, and stub out the components. I spent my time reviewing diffs and filling in the design details — not figuring out where to put files or how to thread props.
Writing and publishing this post
I drafted the outline for this post in a Claude Code session. We went back and forth on structure, I added my own observations, and Claude helped me find the right framing for the technical sections. Once the MDX was in shape, I dropped it into content/blogs/ and it was live. The writing still required my experience and voice — but I wasn't staring at a blank page.
What Actually Got Better
I'm wary of productivity statistics that feel made up, so I'll be specific about what changed rather than claiming a percentage improvement.
Fewer context switches. The biggest time sink in development isn't writing code — it's the constant switching between editor, browser, docs, terminal, and back. When the answer to "how does this API work?" is a question I can ask in-editor rather than a tab I have to open, the context switch disappears. I stay in flow longer.
Boilerplate drops to near zero. Repetitive scaffolding — types, interfaces, test stubs, config files — used to be something I just accepted as part of the job. Now I generate it and review it, which is faster and produces the same output.
Debugging is faster at the diagnosis stage. The part of debugging that takes the longest isn't fixing — it's understanding what's wrong and why. Having an agent that can read the error, trace it through the codebase, and explain the root cause dramatically shortens that phase.
First draft to working code is faster. For greenfield work, the gap between "I know what I want to build" and "I have something that runs" is much smaller. I spend more time on the interesting decisions and less on the mechanical ones.
How to Set This Up
If you want a similar workflow, here's the straightforward path:
1. Get Cursor. Download it from cursor.com. Import your VS Code settings — it takes about 30 seconds and you'll have all your extensions and keybindings immediately.
2. Install Claude Code. Run npm install -g @anthropic-ai/claude-code and authenticate. The quickstart covers setup in full.
3. Start with contained tasks. Don't begin by asking the agent to rewrite your whole app. Start with: "explain this function," "add error handling to this route," "write a test for this component." Build trust in the output before expanding the scope.
4. Review everything. Cursor shows diffs before applying them. Claude Code explains what it's about to do before it does it. Use these checkpoints. The agents make mistakes — catching them in review is much cheaper than debugging them later.
5. Be specific about intent, not implementation. "Add pagination" works better than "add a page query param and slice the array." Tell the agent what you want to achieve; let it figure out the how. If you don't like the approach, redirect it.
6. Keep a CLAUDE.md in your repo. Claude Code reads this file at session start. Use it to document your stack, conventions, and any hard rules ("don't use any in TypeScript," "all API routes go in app/api/"). This shapes every interaction without you having to repeat yourself.
The Bigger Shift
The productivity gains are real, but they're not the most important thing that changed.
What changed is where I spend my cognitive energy. The mechanical parts of development — boilerplate, scaffolding, syntax lookup, repetitive refactors — used to consume attention that could have gone to design decisions, architecture, and the actual problem being solved. When those tasks are delegated, you think at a higher level more consistently.
This isn't about moving faster for its own sake. It's about spending more of your working day on the parts of the job that are actually hard and actually interesting. Cursor and Claude Code don't make those decisions for you — they make it easier to get to them.
The tools will keep improving. The workflow principle won't change: the more you can delegate the mechanical, the more you can own the meaningful.
Using a similar setup? I'd be curious what's working (or not) — find me on X.