I built a full PDF chat application last week and never hit a single rate limit. While the rest of my timeline complained about Anthropic throttling their Claude subscriptions, I kept coding through the night with a model running on the RTX 3090 sitting under my desk. The trick is not magic. It is a 24GB GPU, the right model, and a router that makes Claude Code talk to your local endpoint instead of the cloud.

This post is the exact recipe. Not the generic “you can run local models” pep talk, but the specific VRAM math, the specific model picks for a 24GB card, and the specific tool wiring that lets you keep the Claude Code interface you already love while pointing it at your own hardware.

Why does a 24GB GPU matter for replacing Claude Code?

24GB of VRAM is the sweet spot for serious local coding work in 2026. That number lines up with the RTX 3090, the RTX 4090, and the RTX 5090 entry tier. Below 24GB you are forced into heavily quantized small models that fall apart on multi file edits. Above 24GB you are spending money on prosumer cards that most people will not buy.

The reason 24GB matters specifically for replacing Claude Code is context length. Claude Code routinely loads three or four files into a single turn, runs a tool call, then loads three more. That eats tokens fast. On a 24GB card you can load a capable coding model and still keep a context window large enough to actually do agentic work. Drop below that and you are constantly hitting the same context wall I hit in the video when I tried to load an entire git book into a smaller deployment.

If you want the full breakdown across different card tiers, I wrote a detailed VRAM requirements guide for local AI coding that maps GPU memory to realistic model and context combinations.

What model should I run on a 24GB GPU to replace Claude Code?

My current default is Qwen 3 in the coding optimized variant. On 24GB you have two practical configurations and they trade off against each other.

The first configuration loads the larger Qwen 3 coder build with a moderate context window of around 50,000 tokens. This is what I use for the actual coding sessions. The model is smart enough to plan, smart enough to write a Next.js route file, and smart enough to call tools without getting confused. 50,000 tokens is plenty for a coding turn that touches five or six files.

The second configuration drops to a 7 billion parameter Qwen variant but pushes the context window up to 250,000 tokens. I use this when I need to stuff an entire document into memory, like a 200 page PDF for retrieval testing. Generation gets noticeably slower because the GPU is shuffling all those KV cache tensors, but it works.

You cannot have both at once on 24GB. That is the constraint. Pick the configuration that matches the task. For replacing Claude Code specifically, the first configuration is what you want loaded by default. Big context with a smaller model is a niche tool, not a daily driver.

The honest tradeoff is that even Qwen 3 on 24GB is not as smart as the cloud Claude model. I hit a routing bug in my Next.js project where the local model got stuck in a loop trying to fix the same file. I switched to cloud Claude, pasted the same prompt, and it solved the problem in one shot. That is the local AI coding reality check you have to internalize. Local replaces 80 percent of your sessions, not 100 percent.

How do I wire Claude Code to talk to my local model?

The piece that makes this whole workflow click is Claude Code Router, which is a community tool usually invoked as CCR. Instead of running the standard claude command, you run ccr code. CCR intercepts the API calls Claude Code would normally send to Anthropic and reroutes them to whatever endpoint you configure. In my setup that endpoint is LM Studio running on localhost.

LM Studio is the easiest way to host the model. You download it, pull a Qwen build from the model catalog, set your context length, and click start server. It exposes an OpenAI compatible endpoint. CCR points at that endpoint. Claude Code thinks it is talking to Claude. The model thinks it is fielding a normal chat request. Everyone is happy.

If CCR is not your style, the same pattern works with Cline, Continue, and Aider. Cline runs as a VS Code extension and lets you point at any OpenAI compatible base URL directly in its settings panel. Continue works similarly with a config file that takes a baseURL and apiKey. Aider accepts an openai api base flag on the command line. All four tools end up calling the same LM Studio server. The Claude Code plus CCR combination is my preference because the Claude Code agent loop is the most polished, but Cline is a strong second if you want something visual.

One environment note that saves a lot of pain. Run all of this inside Windows Subsystem for Linux if you are on Windows. The agents expect bash commands like ls and grep, and they get confused when PowerShell answers back. WSL also gives you a clean isolated environment which matters for the next part.

Should I use dangerously skip permissions with a local model?

Short answer, yes, and the local setup is exactly why it is reasonable.

Claude Code has a flag called dangerously skip permissions. It does what it sounds like. The agent stops asking before every shell command and just runs them. On the cloud version of Claude Code most people are nervous about this flag because the agent is operating in your real environment with your real credentials.

When you replace Claude Code with a local model running inside WSL, the calculus changes. The model is bounded by the WSL sandbox. Your Windows files are not directly exposed unless you mount them. There is no API key burning down with each tool call because the model is on your GPU. So you can safely turn the agent loose and let it write files, install packages, and run dev servers without interrupting you every thirty seconds.

That speed difference compounds. A coding session where the agent has to ask permission every command takes three times longer than one where it just runs. When you are doing genuine unlimited AI coding sessions on local models, you want that speed back.

Get my open source local AI starter projects so you can clone the exact LM Studio plus CCR setup I am running. Browse the local AI projects and skip the hours of YAML wrangling.

How does the actual workflow compare to cloud Claude Code?

The flow looks almost identical to normal Claude Code. I open WSL, navigate to my project, run ccr code with the dangerously skip permissions flag, and paste an initial prompt explaining what I want to build. I usually ask the agent to read a spec document I prepared, then write a more detailed implementation plan as a todo list. Shift tab into plan mode, let the GPU spin up, watch the plan get written.

Then I approve the plan and let the agent build. On the PDF chat app I built in the video, the agent scaffolded a Next.js project, wrote the AI integration component, created a fetch call against my LM Studio endpoint so the same model that was writing the code would also power the running app, and produced a working package.json. All of this happened with my GPU pegged at full utilization and zero rate limit warnings.

A few things degrade compared to cloud Claude. The model picks slightly outdated package versions sometimes, which means I update dependencies manually after the scaffold. The model occasionally gets stuck on a specific class of routing problem that requires a smarter model to break out of. And tool calls are a touch slower because token generation on a 24GB GPU is not as fast as Anthropic’s serving infrastructure.

What does not degrade is the core loop. Read files, plan, edit, run, observe, repeat. That works perfectly on local. And because there are no rate limits you can run the loop for eight hours straight if you want to.

What about agentic workflows with multiple specialized models?

This is where the real power of local shows up. On cloud Claude Code you are paying per token for every sub agent invocation, which forces you to design agents that minimize calls. On a 24GB GPU you can run a primary coding agent and swap to a smaller specialist model for routine tasks like summarization, file naming, or commit message generation without thinking about cost.

I dig into this pattern in detail in my post on sub agent strategies for local AI coding. The short version is that you load your main coding model in LM Studio as the default, configure CCR to route specific task types to a smaller model running on a separate port, and let the system fan out work automatically. A 7 billion parameter model is plenty for a “write a one line commit message” sub agent and it runs in milliseconds.

This is the architectural advantage that local gives you. Cloud Claude Code is one model. Local Claude Code is a fleet you compose to fit the work.

What are the honest limits of this 24GB setup?

I will not pretend the 24GB local replacement is a complete one for one swap. Here is where I still reach for the cloud.

Long context retrieval over hundreds of pages does not work well at production speed. As I showed in the video, loading a full PDF book into 250,000 tokens of context made the GPU usable but the response generation was painfully slow. For document chat over big corpora you should still chunk and embed, not stuff context. That is a different architecture and one I have walked through in other guides.

Stubborn debugging that requires deep multi step reasoning over a confusing codebase is still better on cloud Claude. The local model gets into loops where it makes the same wrong fix three times in a row. When you spot the loop, kill the session, switch to cloud, and let the smarter model break the deadlock. Then go back to local for the rest of the build.

And finally, if you are working on something where the response quality on the very first attempt matters, like writing customer facing copy or a technical proposal, cloud is still ahead. Local is for iteration. Cloud is for finals.

Closing

Replacing Claude Code with a local model on a 24GB GPU is no longer a hobby project. It is a practical workflow you can set up in an afternoon. CCR plus LM Studio plus Qwen 3 plus WSL plus dangerously skip permissions equals unlimited coding sessions on hardware you already own.

The full walkthrough including me actually building the PDF chat app on local hardware is on my YouTube channel here, AI Coding Without Rate Limits (Local Claude Code).

If you want to go deeper on local AI engineering and get help wiring this into a real production stack, come join the AI native engineering community at https://aiengineer.community/join. We share configs, troubleshoot GPU setups together, and build the next generation of local first AI applications.