The AI Hack That Actually Speeds Up Coding

The AI Coding Bottleneck We All Secretly Hate

Everyone knows the feeling: you ask your AI pair programmer for a change, watch the spinner, and your momentum evaporates. You were ready to refactor a component or ship a quick fix, and instead you sit there while a “smart” model slowly narrates your own idea back to you. That delay does not just waste seconds; it shatters the fragile flow state that makes coding feel effortless.

Modern AI tools quietly make this worse because the smartest models are usually the slowest. GPT-5, Claude 4.5 Sonnet, Gemini Ultra—these frontier systems excel at deep reasoning, multi-step planning, and architecture decisions. But when you ask them to actually rewrite files, generate boilerplate, or apply a simple UI tweak, their latency turns into a tax on your attention.

Developers now face a constant tradeoff: use a fast model that feels snappy but occasionally dumb, or a brilliant one that responds like it is on dial‑up. Multiply that by hundreds of prompts a week and you get a new kind of AI coding bottleneck. The tools that promise acceleration end up injecting tiny stalls into every iteration.

Pro users have started to route around this, and one of the most effective fixes hides in Cursor’s Plan mode. Creator Robin Ebers calls out a feature he uses “probably 20 times a day”: you do not have to plan and implement with the same model. You can let a heavyweight planner think through the change, then hand off the grunt work to something much faster.

In practice, that looks surgical. You spin up a plan with GPT-5 high for a non-trivial refactor or feature—say, reworking a promo banner component so marketing can change colors and copy safely. Cursor generates a detailed, multi-step edit plan in the background, using the expensive model exactly where its reasoning shines.

Then, instead of waiting for GPT-5 to trudge through file edits, you flip a dropdown to Claude 4.5 Sonnet and hit Build. The plan stays the same; only the execution engine changes. You get GPT-5‑level strategy with Claude‑level speed, and your coding rhythm never stalls.

That split—brains for planning, speed for doing—is the foundation for a workflow that stops forcing you to choose between intelligence and velocity.

Your AI Has a Split Personality. Use It.

Most AI coding tools behave like a single, monolithic brain: you point one giant model at a problem and hope it does everything well. Cursor quietly breaks that assumption with Model Switching in its Plan mode, and it changes how you think about AI help. Instead of one model doing all the work, you give different models different jobs.

Cursor’s Plan mode already splits work into two phases: planning and implementation. The planning phase asks the model to deeply understand your codebase, infer intent, and sketch a multi-step strategy. The implementation phase just needs to churn through edits, refactors, and file changes as fast as possible.

Those two phases stress completely different strengths. Planning needs heavy-duty reasoning: understanding cross-file dependencies, migration steps, edge cases, and rollback paths. Implementation needs speed: high token throughput, low latency, and the ability to apply a 10-step diff across a project without pausing your brain.

Model Switching lets you wire that directly into your workflow. You can generate the plan with a “genius” model like GPT-5 high, which Robin Ebers calls “the best planning model,” and then hand off execution to a “sprinter” like Claude 4.5 Sonnet. Cursor preserves the plan, so swapping models after planning does not throw away the strategy you just paid for.

That separation matters because GPT-5 high is powerful and slow enough to “kill your vibe.” In the demo, Cursor uses GPT-5 to design a change to a promo banner component, then switches to Claude 4.5 Sonnet before hitting Build. The edits land much faster, but they still follow the GPT-5-authored blueprint.

Think of it as a mini production pipeline in your editor. You use: - A high-intelligence planner for architecture and sequencing - A high-throughput executor for file edits and refactors - Optional lighter models like Composer for trivial or repetitive tasks

Instead of one model doing mediocre planning and mediocre execution, you specialize. High-quality thinking gets front-loaded into the plan, while high-speed execution turns that plan into code without dragging your attention through 60-second response times.

The 'Genius Planner' Model: Why GPT-5 Reigns Supreme

Genius-level code generation rarely starts with typing; it starts with a plan. Cursor’s Plan mode leans on that reality by letting you pick a “brains-first” model just for strategy, and GPT-5 currently sits at the top of that food chain. When you care about architecture more than keystrokes, model choice here determines everything that follows.

Developer Robin Ebers goes so far as to call GPT-5 “the best planning model,” and he uses it roughly 20 times a day. That endorsement isn’t about vibes; it’s about reasoning depth. GPT-5 can juggle multi-file contexts, infer hidden dependencies, and outline multi-step changes that cheaper models simply fumble.

Planning with a heavyweight model matters most on work that actually strains your own mental stack. Think:

• Large-scale refactors across dozens of files
• New feature architecture that touches auth, data, and UI
• Novel bug hunts where logs and symptoms don’t line up

On those tasks, GPT-5 doesn’t just list edits; it proposes strategy. It might suggest extracting a shared domain service, flag a leaky abstraction in your API layer, or warn that your “simple” banner change actually needs design tokens, tests, and analytics updates. The plan reads more like a senior engineer’s design doc than a to-do list.

That quality comes with a brutal downside: speed. Ebers flatly says GPT-5 High is “so so slow” that waiting for it to both plan and implement “would just kill your vibe.” For a single Plan + Build cycle, you can watch seconds stretch into half a minute or more, especially on big diffs.

Cursor’s answer is to treat GPT-5 as a genius planner, not a line-by-line code monkey. You let GPT-5 generate the plan, then flip the model dropdown to something faster like Claude 4.5 Sonnet before you hit Build. The plan persists, but the execution now runs on a model tuned for throughput instead of raw IQ.

Cursor documents this split-brain workflow in its Plan and background planning features, alongside other modes in Modes | Cursor Docs. The result: GPT-5 sets the strategy, a faster model ships the code, and your flow state survives.

The 'Speed Demon' Model: Unleash Claude 4.5 Sonnet

Momentum matters more than raw IQ once the plan exists. After GPT-5 sketches a high-level strategy in Cursor’s Plan mode, you don’t need its heavyweight reasoning anymore—you need a model that can slam out code before your brain drifts to Slack, email, or your phone. That’s where Claude 4.5 Sonnet turns into a secret weapon.

Cursor lets you freeze the GPT-5-generated plan and hand off the actual “build” step to a different model from a dropdown. You keep the same carefully reasoned steps, the same file edits, the same diff preview—only the engine executing them changes. Planning stays premium; implementation goes turbo.

Claude 4.5 Sonnet sits in that sweet spot: strong enough to follow a complex multi-file plan, fast enough to feel almost instant. Robin Ebers calls GPT-5 “so so slow” for execution because you can literally watch your flow state evaporate while it streams. Swapping to Claude 4.5 Sonnet slashes that wait from many seconds to something that feels closer to a normal keystroke delay.

The demo in the video looks trivial—changing the color of a promo banner on a landing page—but that’s exactly the point. You don’t want a 20-second GPT-5 think step for a cosmetic tweak. Cursor generates the plan with GPT-5, then Ebers flips to Claude 4.5 Sonnet and hits “Build,” getting the edits applied in what feels like real time.

That speed does more than save a few seconds; it blocks context switching before it starts. When the code appears quickly, you stay locked on the problem, scanning diffs, running tests, and queuing the next change. No wandering to documentation rabbit holes, no doomscrolling while tokens drip in.

Used 20+ times a day, this pattern compounds. You might: - Plan complex refactors with GPT-5 - Execute each plan chunk with Claude 4.5 Sonnet - Immediately iterate on the result without ever leaving Cursor

Over a full workday, those micro-accelerations add up to dozens of uninterrupted micro-sprints. The genius brain designs the move; the speed demon actually ships it.

A Real-World Workflow That Just Works

Cursor’s promo banner demo looks almost insultingly simple: change a landing page banner’s color. No refactors, no new feature flags, just “make this thing a different color” in a real project with a promo banner component wired into the UI. That simplicity makes it the perfect stress test for whether model switching actually saves time or just adds ceremony.

You start in Plan mode with a plain-English request: “Update the promotional banner so I can easily change its background color.” Cursor pipes that into GPT-5 high, the “best planning model” Robin Ebers says he uses 20 times a day. The model doesn’t just guess; it inspects the codebase, finds the banner, and sketches a multi-step plan that might include updating props, tweaking a theme file, and adjusting tests.

Instead of smashing the glowing “Build” button, you pause at the critical moment. Plan mode has already locked in a high-quality blueprint from GPT-5, but using the same model to execute it would be painfully slow. Ebers calls it vibe-killing for a reason: premium models can drag for dozens of seconds on even small edits.

This is where Cursor’s model switching flips the script. You open the model picker — either from the dropdown in the Plan panel or via the Ctrl+Alt+/ shortcut — and swap GPT-5 out for Claude 4.5 Sonnet. No prompt changes, no new plan, just a different engine wired to the exact same set of steps.

Now you hit “Build.” Cursor hands the pre-approved GPT-5 plan to Claude 4.5 Sonnet, which executes it at high speed: updating the banner component, threading a new `backgroundColor` prop, touching the CSS or Tailwind config, and editing any related layout files. You watch a stack of precise diffs appear in seconds instead of waiting for GPT-5 to grind through the same work.

Because planning and execution stay decoupled, quality doesn’t tank when you chase speed. The “genius” part — understanding the codebase and deciding what to change — still comes from GPT-5. The “speed demon” part — actually editing files and wiring everything up — comes from Claude 4.5 Sonnet.

That two-step loop becomes muscle memory fast: - Plan with GPT-5 - Switch to Claude 4.5 Sonnet - Build

You get elite plans, near-instant implementation, and no broken flow state — even for something as trivial as a color tweak.

Beyond GPT & Claude: Your Full Model Arsenal

Modern Cursor setups don’t stop at GPT-5 and Claude 4.5 Sonnet. Power users treat the model picker like a hardware parts bin, swapping components based on latency, cost, and how “risky” a change feels in their codebase.

Beyond OpenAI and Anthropic, Cursor also exposes Gemini, DeepSeek, and Mistral models, many of them routed through OpenRouter. That means you can mix Google’s long-context reasoning, DeepSeek’s aggressive efficiency, and Mistral’s lightweight speed in the same project.

For quick UI tweaks or log-parsing scripts, a smaller Mistral model often feels instant compared with GPT-5. DeepSeek variants tend to shine on math-heavy or algorithmic tasks where you want deterministic reasoning but don’t need a heavyweight planner.

Gemini slots nicely into “research plus code” workflows: scrape docs, summarize APIs, then generate a starter implementation. When you’re bouncing between product copy, UX text, and React components, Gemini’s multimodal DNA helps keep context coherent.

Privacy-sensitive work changes the equation again. Cursor can talk to local LLMs via Ollama, so you can run models like Llama 3 or Phi-3 entirely on your machine for offline coding, regulated data, or NDA-bound client projects. You trade some raw IQ for zero data egress and predictable latency.

Enabling all this lives behind the cog icon in Cursor. Open Settings → Models, then toggle providers like OpenAI, Anthropic, Google, and OpenRouter, and point Cursor at your local Ollama instance if you use it.

Once enabled, you can: - Pick planner and executor models separately in Plan mode - Switch active models via the chat dropdown - Use keyboard shortcuts (like Ctrl+Alt+/) to open the model picker

Cursor’s own guide, How AI Models Work | Cursor Learn, breaks down strengths, token limits, and ideal use cases so your model lineup feels intentional instead of random.

The Manual Grind vs. The Automated Dream

Manual model switching in Cursor currently feels like a power feature trapped in a slightly clunky shell. You get all this model flexibility, but you pay for it in keystrokes, clicks, and micro-delays that add up when you’re hitting Plan mode 20 times a day.

Cursor technically gives you two main ways to swap brains. You can hit Ctrl+Alt+/ to pop open the model picker, or you can mouse up to the dropdown in the chat or Plan panel and pick GPT-5, Claude 4.5 Sonnet, Gemini, or whatever else you’ve enabled. Both work, but when you’re bouncing between “Genius Planner” and “Speed Demon” on every single build, that extra gesture becomes friction you feel in your wrists.

The pain shows up most when you’re doing lots of small edits back-to-back. Change a promo banner color, tweak copy, refactor a function, adjust a test: each cycle wants GPT-5 for the plan and Claude 4.5 Sonnet for the build. That means: - Trigger Plan - Wait for GPT-5 - Open picker - Switch to Claude 4.5 Sonnet - Hit Build Do that 30–40 times in a session, and you’ve basically turned “model switching” into unpaid admin work.

Cursor’s forums are full of people trying to sand this down. Power users keep asking for app-level auto-switching rules, like “always use GPT-5 for planning in Plan mode, then automatically flip to Claude 4.5 Sonnet for execution” without touching a dropdown. Others want OS-style, model-specific hotkeys: Ctrl+Alt+1 for a favorite Claude, Ctrl+Alt+2 for GPT-5, Ctrl+Alt+3 for a cheap local model.

Auto mode exists as Cursor’s partial answer. Set Auto and Cursor picks a “balanced” model—often something like Claude 3.5 Sonnet—for you, which helps if you don’t care which LLM runs under the hood. But Auto flattens the nuance; it can’t encode your personal rule that architecture plans deserve GPT-5 while routine UI edits should never touch a premium token.

What developers keep asking for is not smarter magic, but finer knobs. Granular per-feature defaults, per-mode preferences, and customizable shortcuts would push this workflow from clever hack to invisible infrastructure.

The Future is Now: Cursor 2.0 and 'Composer'

Cursor’s next act, Cursor 2.0, takes the model-switching hack and bakes it straight into the editor’s DNA. Instead of you babysitting dropdowns and timing your swaps, the IDE starts orchestrating models on your behalf, at scale, in the background. Model choice stops feeling like a manual tweak and starts behaving like part of the runtime.

At the center sits Composer, Cursor’s new in-house model. It’s a specialized Mixture-of-Experts engine tuned for bread-and-butter coding tasks: refactors, bug fixes, small feature iterations, and test generation. Cursor claims roughly 250 tokens/sec, putting Composer in the “4x faster than mid-frontier models” bucket while matching the quality of Claude 4.5 Haiku or Gemini Flash 2.5 for routine edits.

Composer doesn’t try to out-think GPT-5 or Claude 4.5 Sonnet on deep architecture questions. Instead, it optimizes for latency and throughput on the 90% of work that looks like “wire this up,” “fix this error,” or “apply this pattern across 12 files.” That makes it the default execution engine once a solid plan exists, slashing the dead time between idea and diff.

Cursor 2.0’s background planning mode formalizes what power users already hacked together: one model that thinks hard, another that types fast. While you keep coding, a heavier planner model—GPT-5, Claude 4.5 Sonnet, or similar—silently crawls your codebase, builds mental models of your architecture, and drafts multi-step change plans. Those plans then feed directly into faster executors like Composer without another prompt or manual toggle.

Multi-agent parallelism scales this even further. Cursor can spin up multiple agents at once: - A planner agent reasoning over architecture and dependencies - A Composer agent applying mechanical edits across files - A review agent commenting on risks, tests, and edge cases

All of that runs concurrently, so a “simple change” no longer serializes into three separate AI conversations.

Taken together, Cursor 2.0 turns the model-switching trick from a clever user workflow into a native system feature. The IDE itself decides when to reach for GPT-5-level reasoning and when to unleash Composer’s 250 tokens/sec firehose. You still control intent—what you want changed—but Cursor increasingly owns the orchestration, making the plan/execute split feel as automatic as syntax highlighting.

Is This The End for Standalone VS Code Plugins?

Cursor doesn’t feel like “VS Code with AI.” It behaves more like a new IDE species where chat, inline edits, and background agents all share the same brain and context. That stands in sharp contrast to a typical VS Code stack where GitHub Copilot or Codeium bolt onto an editor that still treats AI as a fancy autocomplete box.

Standard VS Code workflows usually juggle multiple extensions: Copilot for completion, a separate chat sidebar, maybe a refactoring tool, plus whatever you wired to your local Ollama models. Each plugin maintains its own partial view of the project, its own UX, its own limits. You end up orchestrating the tools instead of shipping code.

Cursor collapses that orchestration into a single, multi-model environment. Plan mode runs a slow, reasoning-heavy model like GPT-5 to design a refactor, then hands the exact same plan to a faster executor like Claude 4.5 Sonnet for edits, without losing context or re-prompting. Chat, diff views, and file edits all feed the same codebase-aware memory, so your AI agent knows the repo structure, not just the open file.

Native codebase awareness is a critical differentiator. Cursor indexes the entire project and lets agents operate over it directly: “migrate this feature from Redux to Zustand across the app” becomes a single plan-and-build flow. In VS Code, you often hit token limits, manual file selection, or brittle regex-based search extensions that don’t actually understand the architecture.

Model switching also runs deeper than a dropdown. Cursor exposes OpenAI, Anthropic, Gemini, Mistral via OpenRouter, plus local LLMs through Ollama, all under one UI and one shortcut system. Community threads like Cursor 4.7 "Auto" model selection - Discussions show users already pushing for smarter, automatic routing between models per task.

That raises an uncomfortable question for power users: once you’ve tasted an integrated, agentic IDE, do single-model plugins feel like using a browser without tabs? Copilot-in-VS-Code still helps, but compared to Cursor’s unified planning, execution, and repository-scale reasoning, it starts to look like legacy tooling dressed up with LLMs.

Your New Superpower: The 20x-a-Day Habit

Mastering Cursor’s model switching stops being a party trick the moment you use it 20 times a day. That quote from Robin Ebers isn’t hyperbole; it’s a description of a professional discipline. You don’t become “the person who ships insane amounts of code” by occasionally toggling GPT-5 on for a fancy refactor—you get there by making this split-brain workflow muscle memory.

Treat your next task as a test run. Open Plan mode, pick GPT-5 high for the plan, and describe your change in one clear sentence: “Add dark mode to the dashboard,” “Refactor auth into separate services,” “Replace the promo banner’s color system.” When the plan lands, resist the urge to hit build immediately.

Now flip the switch. Drop the execution model to Claude 4.5 Sonnet (or your fastest local model), then click build and watch the difference. You keep GPT-5’s architecture-level thinking, but you get implementation at a speed that doesn’t murder your flow state. For small tasks that don’t need heavy reasoning, try Composer in Cursor 2.0 and benchmark how often you actually miss the bigger models.

Turn this into a habit you can measure. For the next day, force yourself to use plan/execute on every non-trivial change: - New feature - Non-trivial bug - Multi-file refactor

If you aren’t hitting Plan mode 15–20 times, you’re under-using your tools. Once this cadence feels normal, your “default” coding loop changes: you stop manually orchestrating every step and start delegating structure to GPT-5 while Claude 4.5 Sonnet and friends handle the grind. That combination quietly becomes a genuine superpower—not because AI writes code for you, but because you can think bigger, move faster, and ship more ambitious software than the dev in the next repo tab who still treats their AI as a chat box.

Frequently Asked Questions

What is AI model switching in Cursor?

It's a feature allowing you to use one AI model (like the powerful but slow GPT-5) to create a development plan, and then switch to a different, faster model (like Claude 4.5 Sonnet) to execute that plan, optimizing for both quality and speed.

Why use different AI models for planning vs. execution?

Planning benefits from models with superior reasoning and architectural understanding (e.g., GPT-5), while execution benefits from models optimized for speed to avoid workflow interruptions. This hybrid approach gives you the best of both worlds.

Which AI model is best for planning in Cursor?

High-reasoning models like GPT-5 or Anthropic's latest Opus/Sonnet series (e.g., Claude 4.5 Sonnet) are recommended for their ability to generate high-quality, comprehensive plans for complex coding tasks.

Is Cursor's new Composer model better than GPT-5?

Composer is designed for speed and excels at routine tasks like writing tests or fixing lint errors, often being 4x faster. For novel architectural problems or complex reasoning, frontier models like GPT-5 or Claude Sonnet 4.5 are still superior.