Claude Code: Things That Made Me Switch from Cursor

I was a Cursor loyalist for 1.5 years. The AI-powered IDE felt like magic when it first launched. But after spending serious time with Claude Code, I’m not going back.

The difference isn’t about which model is smarter. It’s about workflow. Claude Code lives in the terminal, where I already spend most of my time. It integrates with my existing tools rather than replacing them. And the features that seem minor on paper - thinking levels, hooks, subagents - compound into a fundamentally different development experience.

Here’s what actually matters after using it daily.

The `!` Prefix: Skip the Translation Layer

This one seems trivial but changed how I work. Prefix any command with ! to execute it directly without Claude interpreting it.

! git status
! npm test
! docker ps

The output feeds back into context, but you skip the token cost and latency of Claude parsing your intent. For deterministic commands where you just want output, this is faster and cheaper.

Extended Thinking: The Three Levels

Update: 17-January-2026 - This fetaure has been removed and by default it’s alwaya on extended thinking mode.

Claude Code supports explicit reasoning budgets triggered by natural language. This took me embarrassingly long to discover.

Level	Token Budget	Trigger Words	When to Use
`think`	4,000 tokens	”think”, “consider”	Routine debugging
`megathink`	10,000 tokens	”think hard”, “megathink”	API design, schema planning
`ultrathink`	31,999 tokens	”think harder”, “ultrathink”	Architecture decisions, complex migrations

The mental model: reserve ultrathink for decisions where the cost of error exceeds $5 or time savings exceed 1 hour. If you’re using it for everything, you’re burning tokens for no reason.

claude "Design a rate limiting system for our API - think harder about edge cases and failure modes"

Plan Mode: Think Before You Code

Press Shift+Tab twice (or Option+M) to enter Plan Mode. Claude creates a strategy before touching code.

%%{init: {"layout": "elk"}}%%
flowchart LR
    Plan[Plan Mode] --> |"discuss approach"| Refine[Refine Strategy]
    Refine --> |"user approves"| Implement[Implementation]
    Implement --> |"issues found"| Plan

In plan mode you can:

Explore multiple approaches
Recent Surprise: The questions that comes from Claude
Discuss trade-offs before committing
Request pros/cons for unfamiliar technologies

This “plan → discuss → refine → code” flow prevents the expensive rework cycle where Claude builds the wrong thing confidently.

The `@` Symbol: Explicit File References

Instead of asking Claude to find files (slow, token-expensive), reference them directly with @ and tab completion.

@package.json
@src/components/Header.tsx
@api/routes/auth.ts

When you reference a file, Claude automatically pulls CLAUDE.md from that file’s directory and all parent directories. You get localized context without manually specifying it.

For interconnected changes, reference multiple files together:

> Refactor the payment flow:
  @src/services/payment.ts
  @src/api/stripe.ts
  @src/models/Transaction.ts

This prevents Claude from making changes in isolation that break integration points.

CLAUDE.md Hierarchies: Persistent Memory

Few developers realize Claude Code supports context layering through multiple CLAUDE.md files:

~/.claude/CLAUDE.md          → global defaults
project/CLAUDE.md            → project-wide settings
src/api/CLAUDE.md            → API-specific context

More specific files override general ones. Store architecture decisions, team conventions, known issues. Claude reads all applicable files when starting in any directory.

# Architecture
- Frontend: React + TypeScript + Tailwind
- Backend: Node.js + Express + PostgreSQL

# Recent Changes
- Migrated auth to OAuth2 (see @src/auth/oauth.ts)

# Known Issues
- Race condition in concurrent uploads (GitHub #427)

Hooks: Deterministic Automation

The problem with telling Claude to “always run linting after edits” is that it’s probabilistic. It might forget. Hooks execute shell commands at specific lifecycle events - they always run.

{
  "hooks": [
    {
      "event": "PostToolUse",
      "matcher": "Edit",
      "command": "cd {{ workingDirectory }} && pnpm lint:fix {{ filePath }}"
    }
  ]
}

Hook Event	When It Executes	Use Case
`PreToolUse`	Before any tool invocation	Validate inputs, block risky operations
`PostToolUse`	After tool completes	Auto-format, run tests
`SessionStart`	At session initialization	Load environment, recent git diffs
`SessionEnd`	When session ends	Push to staging, send notification

Hooks operate at the deterministic shell level. Unlike model-based instructions, they can’t be skipped.

Keyboard Shortcuts That Matter

Shortcut	Function
`Esc + Esc`	Rewind to previous code state
`Shift+Tab` or `Option+M`	Toggle Plan Mode
`/vim`	Enable vim-style editing
`Ctrl+G`	Open external editor for long prompts
`Ctrl+R`	Reverse search command history
`Ctrl+V`	Paste images from clipboard

The Ctrl+G shortcut opens your $EDITOR for writing complex prompts. Set EDITOR=cursor to compose in Cursor, then return to Claude Code for execution.

Subagents: Specialist AI Instances

Subagents are separate Claude instances with restricted tool access and independent context. They’re ideal for separating concerns.

---
name: code-reviewer
description: Expert code reviewer
model: sonnet
tools: [Read, Grep, Glob]
---

You are a senior code reviewer. Focus on:
1. Code quality and maintainability
2. Security vulnerabilities
3. Performance implications

The pattern: use a research subagent (Read, Grep only) to explore the codebase, then return findings to main Claude for implementation (Edit, Bash). The main conversation isn’t polluted with intermediate analysis.

Session Management

Named sessions prevent context contamination across features:

claude --session-id "feature/dark-mode"
claude --resume "feature/dark-mode" -c "continue with the next step"

The --continue / -c flag resumes your last session. Named sessions let you maintain parallel threads for different features.

Model Switching Without Context Loss

The /model command (or Option+P) switches models mid-session without clearing context.

/model opus    # Switch to Opus for architecture decisions
/model sonnet  # Switch back for implementation
/model haiku   # Use lighter model for simple tasks

Start with Sonnet, escalate to Opus when reasoning gets complex, drop to Haiku for routine operations. Context persists across switches.

The `/compact` Command

After extensive back-and-forth, context accumulates. Each follow-up resends all prior history. The /compact command summarizes the conversation and launches a fresh session with that summary preloaded.

This reduces token costs by 40-60% on long sessions.

Headless Mode for Automation

The -p flag transforms Claude Code into a scriptable tool for CI/CD:

claude -p "explain this error log" < errors.log
cat logs.txt | claude -p "find anomalies"

Use this for automated code review, translation workflows, batch processing.

Custom Slash Commands

Create reusable commands as markdown files:

# Project-level (shared with team)
mkdir -p .claude/commands
echo "Analyze this code for security vulnerabilities:" > .claude/commands/security.md

# Personal (user-level)
mkdir -p ~/.claude/commands
echo "Review this code for performance issues:" > ~/.claude/commands/optimize.md

Invoke with /security or /optimize. Commands support dynamic arguments with {arg1} interpolation.

What Changed My Mind

The combination of these features creates something different from a chat interface with code capabilities. Claude Code is a programmable development partner.

The terminal-native approach means I’m not context-switching between IDE and AI. The hooks and subagents mean I can automate the boring parts reliably. The session management means I can maintain multiple threads of work without polluting context.

Cursor is still excellent for visual work and quick edits. But for serious development sessions - the ones where I’m deep in a codebase for hours - Claude Code is where I live now.

Using Claude Code? I’d love to hear what workflows you’ve developed. Reach out on LinkedIn.