I got banned on Claude Code for my $200 account

This was not a disposable account or a test account; it was a normal main account with a year and a half of paid history. The maximum paid account that had already “started to understand me well,” and around which a software factory and an experimentation factory had already been built, was irreversibly disabled without warning.

And this is a great story to deeply reflect on this whole topic. Let's talk about fragility, our harness, replaceability, and a bit about people.

Background of the bank and slopware factory

At first, I tried to understand what exactly it was for. I am not involved in criminal activities, I don’t hack, I don’t use openclaw or similar services, just development at maximum limits. Of course, there were sometimes instances of website scraping, some bypasses of guardrails, but these happened episodically throughout the entire history of the account. So why was the paid account banned without strikes in one day?

Anthropic positions Claude Code as a tool for writing code. In fact, that’s mostly what I did. I just wrote automatically and hit the ceiling of all limits every week. When you are not writing code yourself from the console but building a software factory with an autonomous cycle of the entire SDLC, then there is a dangerous line between “power user” and “misuse” in terms of Terms of Service.

When you have a CLI tool that can get any task through “-p” (it doesn’t matter whether for checking diff merges or writing new code), the temptation to build autonomous solutions is too great.

Queues, sprints, retries, posthooks — all of this is around the most powerful console utility in the history of console utilities. It’s a kind of slop software factory that creates many MVPs of various software in a transparent enterprise style, which I can then moderate and continue with the successful ones.

And when they promise you “20x” limits on writing code, not doing it through a subscription is a crime. Because the subscription is heavily subsidized and has significantly more limits than pay-per-use (I’ve seen calculations somewhere (didn’t check myself) that in subscriptions there are roughly tokens worth several thousand dollars in terms of API).

Not using the subscription was a crime, but it seems that it's the very crime for which you get banned. "claude -p" without explicit human involvement is a red carpet to purchasing their API, and when they come for you and if they will — I don't know, but it's better to be more careful.

Well, a ban is a ban, but it made me stop and think about the eternal.

How to Live On

Of course, I’ve heard about mass account bans, but when it concerns your honest account, you start to think about all of this as a whole. And I came up with a few unpleasant points and a few pleasant ones. In my bubble, the share of using Claude Code is huge; people are squeezing the maximum out of its internal features, building something big on top of it, and it looks very cool.

And many treat it as if it’s theirs and it’s forever.

Illusion of Control

At some point, you begin to associate everything built with yourself, that this is your tool. But it’s not yours. Not your model, not your rules, and not even your economy of everything you do. Because at some point, prices may change or limits may be cut (this is already happening), which can completely overturn the operation of the tool.

This is someone else's button that we are allowed to press under certain conditions, and as my experience has shown — access to this button can simply be taken away, turning the entire flow built on it into a pumpkin. Or not?

Of course, getting banned is just getting banned; I’ll simply replace it with another one, and in case of urgent need, it’s always possible to build an interchangeable farm of such accounts. But the whole chain of obtaining an account is also an interesting quest with an illusion of control. European mail, a virtual phone from some British backwater, an Asian VPN, virtual cards, verifications, and ultimately that very ToS, which is written in such a way that allows blocking for the smallest step sideways. There are many points of losing control and hitting the off button.

This was a very unpleasant part, but the glass is more half full than empty.

Building Your Harness

Why did Claude Code, using the same model as in the web but placed in a CLI format and having a well-thought-out TUI (terminal UI), create such a sensation? Because for many tasks, it is not the ability to solve the problem all at once that matters, but having a good plan, timely provision of the right data, proper aggregation of that data, and many other things surrounding the model. This whole thing is called harness — from the English word 'harness,' which translates to some kind of yoke and is exactly what it is.

And it is precisely the excellent level of its harness that allows one not to worry too much about the risks mentioned in the previous point. Of course, if one becomes tied to the internal features of a specific tool and everything that is beyond our control, then losing access to it can be very painful. But if one builds their harness (the best in the world already exists in open-source!) on the idea that the model is merely a replaceable and alienable component, then the criticality of the problem significantly decreases.

This is an excellent engineering approach — changing the model will inevitably change the behavior of the system, but it should be controlled cosmetics. Today it's Claude Code, tomorrow it's OpenAI models, the day after tomorrow it's GLM, Qwen, or any other open-source model deployed locally.

When switching to another Chinese model does not look like "everything has crashed," but rather like "let's look at the benchmarks, tweak and calibrate expectations," then this is definitely something one can live with. It's less magical, noticeably more complicated than one would like, but certainly manageable.

The Reality of Model Switching

Suddenly, one of the main downsides of LLMs here becomes a plus: LLMs are like a genius with Alzheimer's and complete memory loss—they can do anything but constantly forget what we are doing here, what code we want to write, and what we agreed on 15 minutes ago. And without our help, they cannot remember. If we view LLMs as stateless components, then each run requires rebuilding all of the state from scratch: history, specifications, decisions made, artifacts, and outputs of the tools, meaning the entire runtime context.

Therefore, the magic lies not only within the model but also in the harness around it. Moreover, they are dependent on each other — the stronger the model, the simpler the harness around it, and vice versa.

A good harness makes the model a replaceable, but not entirely equivalent component: when transplanted, the behavior changes, but it should still not break the entire process. For this, two things are needed: a sufficiently strong model (our neighbors have excellent models, including in open source) and the entire external layer of the project's memory — documentation, state, architectural agreements, contracts, tests, and much more.

Is this easy? Not really. Is it possible? Yes.

And I also had a rather harsh thought, but if we draw parallels with people, it is conditionally comparable to the departure of the entire team from the project. In real life, this is a disaster and most likely leads to the closure of the project. In the AI-coding world, this is a question of calibration.

Harness forever.

What now

Nothing particularly dramatic. For now, you can access top models, and you need to obtain access to them even through the strangest chains of obtaining that very access. Squeeze the most out of them, without investing in their internal tooling and build extractable pieces that can then easily run on other engines.

But always keep in mind that the magic can end one day, and just be ready for that.

But, by the way, almost a full refund for the last month was made automatically. Guess where I will spend it again.

And for now — let's get to work! (I write about my affairs here)

Thank you!