Why I Cancelled My Claude Code Subscription: An Experiment with Open-Source Models and Smart Routing

A heavy Claude Code user who burned through hundreds of millions of tokens every day recently made a counterintuitive decision — cancelling his $200/month subscription. The reason wasn't that the product was bad. Quite the opposite: it was so good that he realized he was sliding into a dangerous dependency. This analysis traces that creator's thinking process and how he attempted to rebuild his AI workflow using open-source models and smart routing.

The Subsidized "Free Lunch"

This user was a devoted Claude Max subscriber — a self-described heavy power user who at his peak consumed over 700 million tokens in a single day. Running that usage through Anthropic's public API pricing, just two days at that rate would cost over $50,000 at standard rates; even accounting for token caching discounts, it would still run about $1,800. He was paying $200 a month.

Doing that math made him uneasy: the economic model simply doesn't hold up. Either Anthropic's API margins are obscenely high, or it's burning VC money to subsidize user inference costs — getting you hooked first, then hiding the true cost of tokens. "There's no such thing as a free lunch" — AI inference has an energy bill, and someone has to pay it eventually.

He admits he'd reached the point of "getting lazy with AI": opening Claude Code and diving straight into work, no longer thinking about the cost of each request or which model he was using. Subsidized inference plus a polished harness let him work without friction — but quietly planted the seeds of a problem.

The Real Danger: Vendor Lock-in

More unsettling than the $200 price tag was a different question: if Anthropic raises prices tomorrow, tightens limits, or changes how Claude Code works, how much of my workflow would I need to rebuild?

The answer wasn't reassuring. He'd built too much on Claude Code — landing pages and sales pages, automated Meta ad campaigns, video asset generation with Remotion and Hyperframes, content repurposing and metadata generation. He'd even used it for a side project with his son: building a world, writing a story, turning it into a book, a YouTube channel, and a web game to teach kids to read. Claude Code sat at the center of all of it.

He called this state "ignorance debt": the better a tool is, the more you stop questioning it, build everything around it, and end up locked in — whether you realize it or not. The switching cost gets so high you don't want to leave. "That's what any business wants. It's good business." Especially when a company is heading toward an IPO and commercial realities start to bite — today's generous plan could look very different tomorrow.

A New Mental Model: Not One Tool, But an Orchestration Layer

At first he fell into the wrong frame of thinking: searching for a single tool that could replace Claude — Is Codex better? Is Gemini CLI better? But that's the wrong question. Why should one model or one model family handle everything?

The landscape has already shifted. Open-weight models can now do genuinely serious work — from Kimi K3 to GLM 5.2/5.3, DeepSeek^Ad v4, Qwen 3.8, and others. Paired with a model-agnostic open-source agent harness, you can break free from the constraints of Claude, OpenAI, and the major US frontier model families.

The Claude Code alternative he landed on was OpenCode — completely free, model-agnostic, compatible with any provider and any model, and compatible with his existing Claude Code agentic workflows. From there, he redesigned the division of labor:

• Kimi K3 as planner and orchestrator — more expensive but very capable, more approachable than Opus;
• GLM 5.2 for cost-efficiency — handles a large volume of coding tasks and is also an excellent creative writing model;
• DeepSeek v4 Flash for near-free, fast, good-enough handling of simple manual tasks.

Model-agnostic means the tool or framework isn't tied to a specific AI model provider — it can call models from different vendors through a unified interface. The counterpart to this is an agent harness: a runtime framework that enables an AI model to autonomously execute multi-step tasks by maintaining conversation context, calling external tools (like code execution and file I/O), and managing subtask delegation. Claude Code is essentially an agent harness optimized for Anthropic's models; OpenCode's value lies in decoupling that orchestration layer from the model itself, letting users swap out the underlying model without changing their workflow structure. This decoupling is the key step from "using a tool" to "owning an architecture."

Privacy and "I Don't Want Anthropic in My Home"

Beyond the economics, he raised a reason that's often overlooked: data and privacy. He argued that what's truly valuable isn't the output itself — it's that "my unique way of thinking as a human" is being profiled by tools like Claude Code, Codex, and Gemini. They're learning your psychology and building a picture of you.

This concern intensified when he started tinkering with a locally hosted home security system, Raspberry Pi projects, and game emulators: "I don't want Anthropic on my home network." Since locally self-hostable models aren't capable enough yet, he chose Venice as his open-weight model provider — because it has zero data retention agreements with its underlying compute providers, meaning no one stores his inference data and no profiles are built.

Zero data retention means the inference service provider commits to not storing users' request content or model outputs on its servers. Requests are discarded immediately after processing and are not used for model training or user profiling. This contrasts with the default policies of most mainstream AI services — OpenAI, Anthropic, and others typically retain the right to use conversation data to improve their models in their terms of service (even if they offer opt-out options). For use cases involving home network topology, personal business logic, or private creative work, zero data retention agreements provide an additional layer of privacy protection. It's worth noting that the verifiability of such commitments depends on contractual constraints between the provider and the underlying compute provider — users generally cannot independently verify this at a technical level, so a degree of trust is still required.

Smart Model Routing: Real Architectural Capability

The most valuable part of his thinking is the discussion of smart model routing — something most Claude Code users have barely considered.

The core insight is this: your AI agent can carry instructions and system prompts when calling other models. And that routing can be handled within the workspace itself. You use one model to think through "what exactly needs to be done," then hand the plan to a cheaper model to execute it, and bring the "big model" back in only when you need serious final review or auditing.

He gave a key example: the same Opus model can consume vastly different amounts of tokens in Claude Code versus OpenCode. If you drop a bare instruction like "get this done" into a blank workspace with no instructions, the model invents its own instructions and feels its way through the task — smart, but it burns a huge number of tokens. Put that same model into a tightly structured workspace with instructions, skills, and sub-agent profiles, and it has context to work with and operates far more efficiently.

In other words, the better your instructions are in AGENTS.md, the more intelligently the agent can route specific tasks to specific models. This not only produces better performance and results — it saves money. And when you're no longer using Anthropic-subsidized inference, saving money matters.

AGENTS.md is a configuration file in an agent harness that describes behavioral rules for the workspace — essentially an "operations manual" written for the AI. It can define: which types of tasks should go to which model, rules for calling external tools, the responsibilities of sub-agents, and which high-frequency operations should be packaged as "skills" for direct reference rather than regenerated each time. The quality of this file directly determines the token efficiency of the entire workspace — vague instructions lead the model to explore and consume large amounts of context; precise instructions let the model identify task boundaries and complete them at minimal cost. Prompt caching is another cost-saving mechanism: for long system prompts or instructions that appear repeatedly at the start of requests, API providers can cache and reuse their encoded representations, avoiding recomputation on every call — typically reducing costs for repeated content by more than 50%.

An Experiment Still in Progress

He has cancelled his Claude subscription and switched to a Venice Max account at the same $200/month price point, which provides $225 in credits and access to over 300 models. The goal isn't a perfect replica of Claude — it's getting comparable results without a significant increase in spending, at the cost of some convenience.

Now he has to stay conscious of every word and every prompt, because they all cost money: don't send a task to the most powerful model if it doesn't need it; cache large contexts whenever possible; turn repeated instructions into skills stored in behavior context files. He believes this is the true architecture of "owning your own AI."

His conclusion is thought-provoking: maybe you can't run genuine intelligence on machines you own outright — but as long as there are vendors willing to offer models at reasonable prices, the most important thing is to own the workspace itself. No one can shut it down. If one model fails you, you swap in another. You live in a world where there's still a market.

As for whether open-source models, an open-source agent, and smart routing can truly replace Claude Code — or whether he'll come crawling back to subscribe again in a few weeks — the experiment is still running. But for anyone building a business around a single AI provider, the questions he's raised about dependency, lock-in, and control are worth taking seriously.