The Price of a Thought

We’re living through one of those stretches where the ground keeps moving under your feet.

A few years ago, writing software meant writing every line by hand. Then autocomplete showed up. Then AI-assisted suggestions. And now we’re in an era where you describe what you want, hand a prompt to an agent, and it writes whole chunks of the application for you.

This cycle has been accelerating hard for the last year or two. Every single time I use these tools, I’m amazed by what they can do. But what surprises me more is how many people still have no idea how far these tools can actually be pushed.

They’re not experimenting enough. They’re not pushing far enough. They’re not having fun with them.

Instead, most people get stuck on one thing: the cost.

The cost trap

A lot of people look at the AI landscape and assume only the biggest names matter. They see OpenAI and Anthropic building powerful large language models — capable of agentic coding and long-running tasks — and they quietly decide those are the only options on the table.

But they forget to look in the other direction.

Human nature has always been the same: the moment something gets expensive, we start hunting for alternatives. Better deals, smarter options, ways to get the same value without paying the top-shelf price. And coming from a place where hunting for a good deal is basically a lifestyle, I understand that mindset in my bones.

Yes, I personally pay for tools like Claude Code. But from where I stand, these subscriptions get expensive fast. And the reality is you do not always need to spend that kind of money to get meaningful results.

So what’s this post actually about?

Simple: we’re going to go looking for the affordable models and tools available right now — options that give you surprisingly similar capabilities and a real edge in your daily workflow, your programming tasks, and your personal projects.

These tools can help you:

• Build software faster
• Experiment with new ideas
• Ship side projects
• Automate the boring, repetitive work
• Get more done in a day The goal isn’t just “find something cheaper.” The goal is to understand what’s actually possible once you start experimenting instead of staring at a price tag.

AI won’t replace engineers who understand engineering

There’s a lot of noise about AI replacing developers. That conversation is everywhere.

But the people who’ll struggle the most aren’t the ones who use AI. They’re the ones who use AI without understanding the fundamentals underneath it.

Production-ready software doesn’t come out of a prompt. You still have to understand:

• How systems are designed
• How the different pieces talk to each other
• How an architecture decision today shapes your options a year from now
• How complex logic should actually be implemented
• How debugging really works
• How software behaves under real-world load The edge was never “I know how to prompt an agent.” The edge is understanding what the agent is doing, why it works, and how to steer it toward a better answer. That’s the part that lifts you above the challenge everyone else is facing — and it’s the part no model hands you for free.

Use the agents. Experiment. Keep building.

AI agents are powerful. They are not magic replacements for understanding.

The people who’ll get the most out of this era are the ones who use these tools, learn from them, experiment constantly, and keep sharpening their engineering along the way. This is a chance to build more, learn faster, and reach for ideas that used to be out of range.

The future belongs to people who can pair human creativity with machine intelligence.

Okay — enough philosophy. Let’s talk money.

First, adjust your expectations

Before I hand you any deals — before I tell you how to squeeze the most out of your hard-earned cash — there are a couple of compromises you have to make. Some quirks you have to accept. Mostly, you have to reset your expectations.

You are not paying $200. You are not paying $100. Honestly, even $20 is too much for an OpenAI or Anthropic Claude Code subscription in this game plan.

Here’s the ceiling we’re playing with: you pay $1 to start, maybe $5 a little later, and $10 if you really want to bump it up. That’s the top of it. Three deals, three setups — each with its own trade-offs, its own quirks, its own strengths. I’ll walk you through all of them.

And I’m not speaking from a spec sheet here. I’ve run these models across a bunch of different environments and pushed them to their limits. I know how they behave, where their edge cases are, and how to work around them. So let’s go.

Deal #1 — Command Code, the $1 “Go” plan

The first one is the Command Code “Go” plan for $1. One dollar. And you get a lot of cool stuff bundled in — 4× usage on DeepSeek V4, plus MiniMax M3, MiniMo V2.5 Turbo, and Tencent HY3 (Hunyuan). These models would normally cost a fair bit, but Command Code is eating that cost for you. For $1, you can use as much as you want, and the whole thing caps out around $10 of value. Holy shit — there’s genuinely no better deal out there for that much usage.

The default model is DeepSeek V4 Flash, and hands down, it’s a great model. It’s very good at coding, at debugging, at solving issues — if you point it in the right direction. It’s not built for lazy one-liners like “I need this feature here, figure out the edge cases, go.” It’s not at that level of autonomy yet. But it is more than capable of finding the problem and detecting what’s wrong when you give it something to work with.

Real example: the publish button on my writing platform was broken and I couldn’t push a blog post out. So I grabbed this $1 plan, pointed DeepSeek V4 Flash at the publish directory, the publish logic, and the codebase, and told it to go fix it. It worked through the problem and built the fix. Then I took a screenshot to show it that things were looking good, passed it the image — and the model couldn’t read it. That’s the edge case: vision is where it falls over.

Quick heads-up: these are open-weight models, and a lot of them are Chinese models. If you’re privacy-conscious, this might not be your setup. For my use cases — coding, development, general online work — I’m an open book, so this is perfect for me. And I’ve been pushing it hard.

Where it really shines is in a team. I run it alongside Codex and my Claude Code subscription — I just say cmd -p, pick the model, get feedback on the PR, and fix whatever comes back. I’ve also been running it under Fable 5 as the orchestrator: Fable plans and orchestrates, the cheap models do the coding and the review, and then I review on top. Everyone works like a little team, my Fable usage stays low, and I get way more mileage out of these budget models. It’s honestly phenomenal what you can pull off.

I even started a new prototype off the back of it — a small encrypted vault (working name SecuredVault, might end up SecuredPilot, still deciding) where you store all your tokens, SSH keys, everything, and nobody gets in except you, via a session key passed through the terminal or a GUI app. The entire plan for it was drafted by DeepSeek V4 Flash.

And let me be straight about the model: when it comes to UI, it sucks. Ask it to design a good interface and it has no real sense of what “good” means — it’s full of caveats and it just doesn’t land. But for logic building, it’s excellent. When you’re adding functionality or writing code that needs to sit at a Sonnet 4.5 / Sonnet 5 kind of level, it’s genuinely capable. Hand it clear blocks — “here’s the file, here’s the thing, fill these in and open a PR” — and it delivers, over and over.

I’ve also been using GLM 5.2 on OpenRouter (check my previous blog for that one) — great model, really thick in the good way.

The one real downside of the Go plan: no Hermes-agent access. You can’t hook the subscription’s API into your own agent. I was genuinely planning to wire my Hermes agent to it, and I can’t — so that stays half-built for now. If the $1 Go plan ever opened up API access for a custom agent, it’d be unbeatable.

I’ve linked the pricing and my actual token usage below so you can see it for yourself.

Pricing: commandcode.ai/pricing

Deal #2 — Command Code Pro ($15) and Max ($100)

If you want to move up, Command Code has a Pro plan for $15 that gets you around $120 of usage — roughly 25,000 requests, access to their premium open-source models, plus a Discord community and support. (I had the name wrong in my head at first — it’s the Pro plan, not “Zen.”)

Above that, there’s a Max plan for $100 that stretches to about $600 of usage. They are subsidizing these models hard, and it’s a seriously good deal.

There’s also a pay-as-you-go route — $15 to get going, then you pay their API rates — along with team and custom plans. I’ll keep the pricing links in the post so you can check the current numbers yourself, since these things move.

Deal #3 — OpenCode

Now the third one: OpenCode.

The models are pretty similar, but the harness is the story here. Command Code is a closed-source harness — a CLI and an extension. OpenCode is the free, open alternative to Claude Code and every other harness out there: you can run it on their subscription, or bring your own API keys.

On pricing, OpenCode gives you a Go plan around $5 (bump it to $10), or a Zen plan at $20. Both are fine, but I don’t think $20 is worth it for what we’re aiming at here — the $10 Go plan is the sweet spot. You get a better desktop app, a much more mature CLI, an actually open community, and a project that keeps pushing forward. Dax, the main contributor and developer, is spot on — if you follow him on X, his agentic work is genuinely some of the sharpest out there.

So here’s the play: start with Command Code, grab that $1 deal, and ride it until it’s used up — you’re getting the same class of models, the same behavior, the same edge cases. Then, once you’re convinced OpenCode is a worthy alternative, jump over — your first month there runs about $5.

Links: opencode.ai · commandcode.ai

I actually put OpenCode through its paces in my previous post — the GLM review — so go check that out to see how it behaves. And pay attention to this, because it matters: these models produce noticeably different output from one harness to the next. Same model, different wrapper, different result.

A quick word on harnesses — because this is the real game

If you don’t know what a harness is: a harness is basically the wrapper application — a terminal or a desktop app — that the AI model and its APIs live inside. It sends the requests and executes what comes back. It’s the thing between you and the model.

And harnesses are not equal. In my experience, the Claude Code harness is honestly a bit of a shitty one — it’s riding high mostly on benchmarks. Cursor is really, really expensive and really, really good. OpenCode sits right underneath the top tier and it’s closing the gap fast. There’s a longer tail below that too. I don’t have hard analytics on Command Code, but from actually using it, it’s solid.

Here’s the thing most people miss: building your own harness is not easy. It takes real time and real passion. But that’s exactly where the competition is right now. If you can build a good harness on top of solid API providers — Fireworks, or a platform’s own Zen-style models — and find a host willing to hand out subsidized credits to a growing user base, then you’ve got something special on your hands. The whole battle is happening in the harness layer. And while that battle plays out, our job is simple: grab these tools and push them as far as they’ll go.

So here’s how I’d actually play it

Don’t overthink the money. Start at $1 with Command Code and let DeepSeek V4 Flash surprise you. Wire it into a team with Codex or Fable as the orchestrator. Point it at real problems in a real codebase — not toy prompts — and watch how much it gets right. When you’ve squeezed the Go plan dry, step up to OpenCode’s $10 tier and keep going.

But remember what this whole post is really about. The deals are the easy part. The part that keeps you employed — the part that keeps you ahead — is understanding how the systems actually work underneath all this. Use the agents, learn from them, experiment relentlessly, and get seriously good at what you do.

That’s the price of thought. Pay it, and you’re one step out the door while everyone else is still arguing about the subscription price.

Until then — go break something.