Hitting the Brakes on Claude Code

I’ve been experimenting heavily with Claude Code over the past few weeks, and while I’ve been dumbfounded by the swiftness with which it creates working MVPs from scratch, turning those into production-ready applications remains a hit-or-miss proposition. There have already been several situations where I’d leave Claude unattended, expecting to return to a polished solution. Instead, by the time I checked back, not only would the result be wrong, but Claude would have inadvertently burned through a mountain of tokens in the process.

Thankfully, I pay a flat monthly subscription for Claude Code, which comes with generous allowances. Basically, you can use it all day long, keeping in mind that Anthropic will quota-cap you at certain intervals. When you reach one of those, you have to wait a couple of hours, before you can use CC again.

But we all know this won’t last forever. It’s a gateway drug. Sooner or later, Anthropic will flip the switch and migrate us all to per-token pricing—potentially leading to bills in the hundreds or thousands of dollars per month for zero productive output. Not to mention the environmental impact, though that seems to be the last thing on anyone’s mind these days.

It’s still early days for establishing best practices around optimal token management. All I know is that I don’t want to hemorrhage tokens at breakneck speed with nothing to show for it.

The Need for Speed Bumps #

The natural solution is to introduce deliberate friction into the process. I still want to assign Claude a substantial task and let it work autonomously, but I also want the opportunity to understand what it’s doing—and crucially, to veto misguided approaches—before it burns through millions of tokens chasing the wrong solution.

The simplest fix I discovered was adding a special hook that executes before every significant change:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "sleep 30"
          }
        ]
      }
    ]
  }
}

The implementation varies by IDE, but in VS Code, I add all hooks on a per-project basis inside the .claude/settings.local.json file.

This seemingly trivial delay has improved my Claude Code workflow. It creates intentional, meaningful pauses - enough for me to switch tasks, come back, and intervene before it’s too late. It also naturally slows down the token burning process. Previously, I could get quota-capped in just a couple of hours. Now, it would “waste” the same number of tokens throughout the day.

One could argue that in the end, it does not matter, because I am equally slow, if not even slower. While that might be true, the process is not as harmful, plus, I don’t really mind the slowing down. If not, it gives me an opportunity to be a part of the process, rather than just a reviewer at the very end.

There is a lot one can do with Claude Code hooks, and I am just starting to explore all options. My idea is to create a solution that adapts itself, and sort of progressively slows down CC operations based on token usage. I will report on my findings in future blog posts.