I Was Burning Through AI Tokens Like Kindling. The Fix Was Embarrassingly Simple.

I spent months building an AI-powered publication while hemorrhaging tokens across ChatGPT, Claude, and every MCP connector I could find. The problem wasn’t the tools. It was me — using features I didn’t need to solve problems I didn’t have, creating problems I couldn’t see. The fix came down to three things: structured prompting with explicit version numbers, killing every unnecessary integration, and accepting that more connections doesn’t mean more capability. Here’s the whole messy story.

Revised May 2026 to add a new section on industry-wide token consumption patterns.

I started TemperatureZero in January 2025 with a ChatGPT Plus subscription, a Hetzner VPS I’d barely configured, and the kind of confidence that only comes from not yet knowing what you don’t know.

The plan was ambitious: an independent AI publication with automated daily briefings, a custom design system, and an editorial pipeline that could run while I was at my day job. I’m a father of two. I work fifty hours a week. The window for building something like this is the space between my kids’ bedtime and my own, and it closes fast.

ChatGPT was my first copilot, and I want to be fair to it — because what it did well, it did remarkably well. It helped me dream big. It architected the editorial vision, the content strategy, the category taxonomy. It laid out server infrastructure plans that sounded exceptional. It built up my confidence that this was not only possible but achievable on my timeline. When I needed a creative strategist who could keep pace with my ambition, ChatGPT delivered.

Then I tried to build what it described.

The Version Number Problem (Or: Why Your AI Just Made That Up)

The first thing I needed was an automation pipeline. RSS feeds in, editorial briefings out, published to WordPress on a schedule. ChatGPT mapped out the architecture in n8n — a workflow automation tool I’d installed on my server — and it looked brilliant on paper. Nodes connected in clean logical chains. API calls structured with obvious intent. Error handling that anticipated failure modes I hadn’t considered.

I pasted the workflow in and nothing worked.

The nodes it referenced didn’t exist in my version of n8n. The interface options it listed weren’t there. It told me to install specific versions of npm and Node.js that conflicted with each other. It suggested connection methods for APIs that had been deprecated months earlier. The WordPress hooks it targeted had been renamed or removed.

When I sent it screenshots of what I was actually seeing, it got worse. The screenshots didn’t match whatever reference material it was drawing from, so instead of saying “I don’t recognize this interface,” it improvised. Confidently. It would describe settings panels that weren’t on my screen, reference dropdown menus that didn’t exist, and suggest configuration paths that led nowhere. I’d follow its instructions, hit an error, paste the error back, and watch it generate a new set of instructions that were equally wrong but in a different direction.

I now understand exactly what was happening. ChatGPT was synthesizing its responses from multiple outdated blog tutorials, forum posts, and documentation snapshots — none of which matched the version of n8n I was actually running. I hadn’t told it my version. It hadn’t asked. And because I didn’t know enough yet to recognize the mismatch, every debugging session just compounded the confusion.

I’d burn through ChatGPT’s context window in these marathon troubleshooting sessions — hours of back-and-forth where each message made the model’s responses a little more frayed, a little less coherent, until the browser itself would slow to a crawl under the weight of a conversation that had gone nowhere useful for the last forty-five minutes. I’d ask it to generate an optimized prompt to start fresh (a great strategy for almost anything except what I was doing), fire up a new conversation, and then spend another thirty minutes trying to explain what my workflow looked like by copying code out of individual nodes, exporting JSON files, and sending screenshots that the new conversation had no context for.

I duplicated and trashed that n8n workflow at least ten times before I started building it myself.

The lesson, spelled out: Always write prompts with a clear role definition and explicit context rules. Include the specific version numbers of every tool in your stack. Tell the model to reference only official documentation for your versions — not blog posts, not tutorials, not Stack Overflow. Better yet, find the documentation yourself and paste the relevant sections directly into the conversation. The AI’s training data is a snapshot, and if your tools have been updated since that snapshot, the AI will fill the gaps with plausible-sounding fabrications. The more specific your context, the less room there is for improvisation.

This problem isn’t unique to ChatGPT. It comes up with Claude too, just less often. It’s a fundamental limitation of any language model that was trained on a frozen corpus. The fix is always the same: narrow the context, anchor it to verified documentation, and never assume the AI knows what version you’re running.

The Claude Migration (Or: A New Flavor of Chaos)

After more than a month of this, I switched to Claude Pro. I’d been seeing ads for Claude Code — the command-line tool for agentic coding — and the promise of an AI that could connect directly to my server was irresistible. I didn’t fully understand the difference between Claude.ai (the web interface), Claude Code (the terminal tool), and the various ways they could connect to external services. I just knew I wanted all of it.

I got to work late into the night, and what I built was a masterpiece of over-engineering.

I set up MCP connectors — the protocol that lets Claude interact with external tools and services — everywhere I could find a place to put them. Four different types of WordPress connectors. n8n connectors. API keys scattered across configuration files. I installed them through Claude’s config file (in a deprecated directory path that Claude itself recommended, which meant the folder was created but never actually read by the application). I installed them through developer settings. I installed them through the desktop app’s connector interface. I even had Claude draft custom MCP connectors as code snippets, which worked until the conversation context was lost and the next session had no idea they existed.

At peak chaos, I had connectors in three separate installation locations, most of them broken, all of them loading every time I opened the application. I didn’t know this at the time. What I knew was that I could squeeze out maybe a handful of messages before getting a notification that 90% of my token allowance was gone and I’d have to wait for it to reset. I assumed Claude was just expensive to use, or that my questions were too complex, or that I needed a more powerful plan.

Meanwhile, there was a flashing cascade of warnings in red and yellow on the right side of my screen every time I opened Claude Desktop — my broken MCP connections announcing their failure. I asked Claude about it several times, and it verified that my active MCP connection was intact (it was), but it never warned me about the trail of dead connectors I’d left in my wake while trying to get one to work properly.

Here’s what I didn’t understand, and what turned out to be a well-documented problem across the developer community: every MCP connector — working or broken — injects its full tool definition schema into the context window at session start. It doesn’t matter if the connection fails. The tool descriptions are already loaded, the tokens are already spent, and the error messages from failed connections pile on top. Developers have reported MCP tool definitions alone consuming 66,000 or even 143,000 tokens out of a 200,000-token context window — before typing a single word. I was paying the context tax of every connector I’d ever configured, plus the overhead of the ones that were crashing. It took me far too long to realize that even broken MCP connections were eating my token budget before I asked my first question.

This went on for weeks.

The Three-Headed Hydra

Here’s the part I’m almost embarrassed to admit, except that I know for a fact other people are doing this right now.

I was running Claude.ai in the Desktop application, Claude Code in my terminal, and Claude in Chrome (the browser automation extension) — all simultaneously, all working on the same project, and none of them aware that the others existed.

I’d ask the desktop app to help me fix a CSS issue on my site. I’d ask Claude Code to adjust an n8n workflow. I’d use Claude in Chrome to inspect a page and suggest changes. Each instance would make recommendations that contradicted the others. Each one consumed its own tokens. Each one loaded every broken MCP connector in my configuration. I was paying for three separate AI sessions doing redundant work, generating conflicting advice, and burning my token allowance three times as fast as I needed to.

I didn’t realize they weren’t in communication. It genuinely had not occurred to me that “Claude” in one window didn’t know what “Claude” in another window was doing. They’re the same AI. Same name. Same voice. And here’s the thing that makes it even more disorienting — Claude itself doesn’t know which interface it’s running in. It doesn’t know if you’re talking to it in the desktop app, the browser, or a terminal. It just knows you need help with something. So when I asked each instance about my project, each one responded with the same confidence and the same voice, giving me no signal that it was working in complete isolation. Every conversation is its own sealed room — its own context window, its own token budget, its own complete ignorance of what’s happening next door.

The Breaking Point

About three weeks ago, Anthropic’s servers went down under heavy load. I was mid-session, out of tokens, locked out of the tool I’d come to depend on, and suddenly face to face with the realization that I had no fallback. ChatGPT was still there, but my trust in it for execution work was gone. My workflow was live but fragile. My site existed but wasn’t publishing consistently.

I did what any reasonable person would do: I opened the in-app support bot and vented.

The support bot responded with its calm, multiple-choice menu of options. It asked if I wanted a refund. I didn’t want a refund — I’d clearly gotten value from the service, and Anthropic could keep the money. I just wanted my tokens back so I could get back to work. It was the digital equivalent of screaming at a vending machine that ate your dollar.

The next day, they restored my tokens. And that was the moment I decided to stop treating the symptom and diagnose the disease.

The Fix

I finally asked Claude the question I should have asked weeks earlier: Why am I burning through tokens so fast?

The answer was humbling. Every MCP connector in my configuration — broken or not — was injecting its full tool definition schema into the context window at the start of every session. The broken ones piled error output on top of that. Every conversation was bloated with tool descriptions, connection attempts, and capability declarations from connectors I wasn’t using. My memory entries had accumulated into an unstructured mess that got injected into every session. My Claude Code environment was reading every repository I’d cloned in my collection-obsessed early days, loading context I never needed.

I was using features I didn’t need to solve problems I didn’t have, creating problems I didn’t see, while patching problems I was leaking out like a tokenized breadcrumb trail.

The fix took less than an hour:

I deleted every MCP connector except one — the single WordPress connector that had actually been working the entire time, quietly doing its job in the background while I stacked broken alternatives on top of it. I went through Claude’s memory of me and cleaned it up, removing outdated entries and consolidating context that was being redundantly stored. I organized my Claude Code project directories so the AI wasn’t reading irrelevant repositories every time I started a session. I stopped running Claude.ai, Claude Code, and Claude in Chrome simultaneously.

The result was immediate and dramatic. My token usage dropped to a fraction of what it had been. Sessions lasted longer. Responses came faster. The context window wasn’t being filled with garbage before I even asked my first question.

Since the cleanup, I’ve run out of tokens exactly once.

Setting Money on Fire, On Purpose

There’s a pattern I’ve noticed since I cleaned up my own mess, and it’s weirder than the personal one. The industry has somehow decided that token consumption is a virtue.

You can see it everywhere once you start looking. Engineers posting screenshots of their monthly Anthropic bills as flex. “I burned 30M tokens this week” framed as a brag rather than a question. Tutorials that recommend running the same task through multiple models and synthesizing their outputs when one well-scoped prompt would have done it. Marketing for AI coding tools that emphasizes context window utilization as a feature, not a cost. The implicit message: more tokens means more work, and more work means a better engineer.

This is the dumbest thing I’ve heard from a technical industry in years, and I work in construction inspection. It’s the equivalent of bragging that your car gets one mile to the gallon because that means you’re really using the engine.

Let me be specific about what I’m criticizing and what I’m not. Extended reasoning modes — Claude’s thinking budgets, OpenAI’s o-series, DeepSeek R1 — use more tokens because they’re doing more reasoning. That cost buys real performance gains on hard problems. Agentic workflows that fan out into multiple subagents can be legitimately useful when the subtasks are genuinely parallel. Neither of those is the thing.

The thing is: prompting the same model the same task fifteen times with incrementally more elaborate instructions and calling that engineering. Spinning up multi-agent systems for problems a single well-formed query would solve in one round-trip. Configuring tooling stacks where every session loads tens of thousands of tokens of unused context because someone decided “more capability available” was the same as “more capability required.” Bragging about cost on social media because the alternative — admitting your workflow is wasteful — would mean admitting you don’t understand the tool.

This is the same pattern that produced visible-busyness culture in offices for decades. The engineer who stayed until midnight wasn’t necessarily doing more work than the one who left at six. They were producing more signal of work. AI is now allowing the industry to do this at unprecedented scale and unprecedented cost, with the additional layer that the signal is being purchased from a vendor by the token.

Anthropic and OpenAI both have rational reasons to not push back on this hard — every wasted token is revenue. The platforms have business models that benefit from inefficient usage and lose money on efficient usage. Don’t expect the people selling tokens to be the loudest voices saying you’re using too many. That role falls to people who pay the bills and notice when they’re getting larger for no reason except that the social media account they follow said “always think hard” or “always use deep research” or “always run it through three models.”

Efficiency is a real metric. So is leverage — how much useful output you produce per token. So is reliability — how often a single well-scoped query produces a correct answer versus how often you have to retry. None of these get talked about in the discourse around AI tool usage, because none of them make for good screenshots.

The industry trained itself to confuse activity with progress before AI existed. AI just gave it a spiffier dashboard.

What I’d Tell Myself Three Months Ago

If you’re building something with AI tools and hitting walls that feel insurmountable, here’s what I learned the hard way:

Tell the AI what version of everything you’re using. Every tool, every library, every framework. If you’re running n8n 2.x, say so. If you’re on WordPress 6.9, say so. If you don’t, the AI will reference whatever version is most represented in its training data, and that version is probably not yours. This single practice eliminated more errors than any other change I made.

Write prompts with explicit roles and rules. Don’t just ask “how do I connect n8n to WordPress.” Ask it to act as a senior developer referencing only the official n8n documentation for your specific version, using only nodes and methods that exist in your current installation. Constrain the AI’s creativity to the space where your tools actually operate.

Provide documentation yourself when accuracy matters. If you’re configuring something critical, find the official docs, paste the relevant section into the conversation, and tell the AI to work exclusively from that material. The five minutes spent finding documentation saves hours of debugging hallucinated instructions.

Fewer integrations, not more. Every MCP connection, every browser extension, every concurrent session costs tokens. A single working connection is worth more than ten broken ones. When something isn’t working, the instinct is to add another tool. Resist it. Diagnose what you have first.

Understand that each AI session is isolated. Claude.ai doesn’t know what Claude Code is doing. Claude in Chrome doesn’t know what either of them said. If you’re running multiple instances, you’re paying for each one separately and getting contradictory advice as a bonus. Pick the right tool for the task and use it alone.

Watch your context window. Learn where the usage indicator is in your interface and check it. If it’s red before you’ve asked a question, something is wrong with your configuration, not with the AI.

Know what each tool is good at. ChatGPT is exceptional at strategic planning, creative ideation, and big-picture architecture. It will dream with you and make you feel like anything is possible. Claude is stronger at precise execution, technical accuracy, and maintaining coherent context across complex tasks. I use both — but I stopped asking either of them to be something it isn’t.

Plan your desired outcome in its entirety before you build. Sit down with your LLM and map the whole thing — start to finish — before you touch a single node, write a single line of code, or configure a single connection. If you skip this step, you’ll spend 30 minutes building and 48 hours fixing. That is a story for another day.

None of this is a criticism of the tools themselves. ChatGPT helped me envision TemperatureZero. Claude helped me build it. The problems were always mine — the wrong tool for the wrong job, the wrong assumptions about how the technology worked, and the very human reluctance to stop and read the manual when I was sure I could figure it out faster by just asking one more question.

The site publishes daily now. The automation pipeline runs. The design system works. And the token bill stays manageable — not because I found a cheaper plan, but because I finally stopped setting money on fire and calling it progress.

Maxim Starkweather is the founder and editor of TemperatureZero, an independent AI and technology publication. He builds with Claude, plans with ChatGPT, and has strong opinions about MCP connectors.

AI-generated editorial illustration · TemperatureZero · March 24, 2026