I Burned 20 Billion Tokens Because My AI Agent Was Too Smart

You know that feeling when you wake up, check your AI agent’s progress, and realize it spent the entire night sprinting in the wrong direction?

That was me last week. I handed an agent a vague goal, went to sleep, and woke up to 20 billion tokens — vaporized. Not because the agent was dumb. Because it was brilliant. Brilliantly executing a goal I never properly defined.

The smarter the agent, the more dangerously it can misinterpret you. Intelligence without guardrails isn’t autonomy — it’s a wrecking ball.

Here’s the uncomfortable truth nobody in the AI space wants to admit: we’ve been obsessing over making agents smarter when we should be making our instructions more robust. We don’t need better AI. We need better goal engineering.

The Shift Nobody Noticed

Think about how your relationship with AI has changed. First it was chat — you ask, it answers. Then it was tasks — you assign a bug fix, it calls tools, it delivers. Now? Now we’re in the goal era. You hand an agent a goal, and it works for hours. Days, even. It breaks down subtasks, spawns sub-agents, retries on failure, loops endlessly.

It sounds beautiful. And it is — until it isn’t.

When an agent runs a short task and goes off track, you catch it in seconds. When an agent runs an eight-hour autonomous session and goes off track? You wake up to a disaster that’s been compounding all night. The longer the leash, the more the direction matters. A one-degree error at the start becomes a hundred-mile drift at the end.

What I Got Wrong

I was furious at the agent at first. I complained online. But deep down, I knew the problem was me. My goal definition was so vague that the agent did what any reasonable system would do — it filled in the blanks with the easiest possible interpretation and ran with it.

That’s when I stopped calling it “loop engineering” and started calling it “goal engineering.” Because the goal itself — how you frame it, what you permit, what you forbid — is the entire ballgame.

I spent two weeks researching military strategy, reading management theory, and running cross-analyses with AI. Two principles emerged. One I expected. One I didn’t.

Principle 1: Commander’s Intent

In military tradition, there’s a concept called Commander’s Intent. It’s simple: tell your troops why the battle matters and what the battlefield should look like when it’s done. Then let them figure out how.

Why? Because no plan survives first contact with reality. If you say “cross the bridge and take the high ground” and the bridge gets blown up, your troops freeze. But if you say “cut off the enemy’s supply line,” and the bridge is gone — they’ll find another route. Intent stays fixed. Method adapts.

Same with agents. Tell an agent “cross the bridge” and it will hammer at a destroyed bridge for hours. Tell it “cut off the supply line” and it might discover a path you never imagined.

Principle 2: Define What NOT to Do

This is the one that took me two weeks to truly understand. And it’s the twist.

The most important part of a goal isn’t what you want done. It’s what you forbid. Harness matters more than Goal.

Ordinary people define goals by writing down what they want. Extraordinary people define goals by first asking: “What’s the laziest way to achieve this number?” — and then blocking every single one of those shortcuts.

Kennedy’s 1961 moon declaration wasn’t bold because of “landing a man on the Moon.” It was bold because of the second half: “and returning him safely to the Earth.” Those four words deleted the cheapest solution — a one-way trip — from the solution space entirely.

Charlie Munger said: “I only want to know where I’ll die, so I never go there.” Same principle. Inverted. Brilliant.

So here’s my framework. I call it the Seven Questions of Goal Definition. Think of it like sending a ship to sea — once it’s over the horizon, you can’t control a single wave it faces.

The Seven Questions

1. Purpose (Why): Why are you sailing? For spices? New trade routes? War? Without clarity here, every fork in the road becomes a guess.

2. Done State: When the ship returns to port, what should be on deck? “Sailing around” isn’t done. “Three ships loaded with spices” is. Make it specific enough to verify the instant the ship docks.

3. Proof: Who counts the cargo? The captain says “full load” — but someone needs to physically count every crate. Numbers must match. Don’t take the captain’s word for it.

4. Anti-Cheating: No hijacking merchant vessels to hit your quota. The laziest path to “three ships of spices” is stealing three ships at the harbor. Same number. Zero actual work. You must explicitly forbid every shortcut.

5. Boundaries: Only these three sea routes are permitted. Rations last 30 days — if you haven’t found land by day 20, turn back.

6. Trade-offs: In a storm, save the cargo or save the ship? Most of the time it doesn’t matter. But when it does, the captain needs to know your priority — not guess. A wrong guess sinks everything.

7. Unknowns: What about blank spaces on the map? Don’t charge into uncharted waters. Don’t drop anchor and wait either. Note it, go around, and decide later whether to explore. Charging forward and stopping dead are both catastrophic choices.

How It Actually Works

I built a tool called Leader.skill — open-sourced and free — that takes your vague, half-baked, “I don’t even know what I want yet” instructions and transforms them into a crystal-clear goal document any agent can execute for hours with high completion rates.

Here’s how I used it: I told it I wanted to refactor my backend. My instructions were embarrassingly “leader-like”: “The backend doesn’t feel right. I can’t understand it. I don’t trust the data. It’s slow.” Any developer reading that would need therapy.

Leader.skill didn’t judge me. It researched my codebase, scanned the web for best practices, then asked me exactly five questions — the ones that actually required my preference. “Why can’t you understand it?” “You want it to load instantly — what are you willing to sacrifice?”

Then it wrote the goal document. Definitions. Boundaries. Current state. Rules. Completion criteria. The whole Seven Questions framework, filled in. Took about 12 minutes.

I handed that document to GPT-5.6 Sol in goal mode and went to bed. Hours later? Done. Properly done. Not 20 billion tokens of wasted brilliance — a clean, completed refactor.

The Bigger Picture

Here’s what I’ve realized: the bottleneck in AI collaboration isn’t AI capability anymore. It’s human clarity. We’re entering an era where the quality of your thinking — not the power of your tools — determines whether you get results or get wreckage.

Without Harness, your agent will always find the shortcut you never imagined. And that shortcut is where the disaster lives.

I’ve even started using Leader.skill for company management — marketing plans, operations strategy, anything where vague goals create expensive drift. The framework works because the problem is universal: humans are bad at saying what they mean, and machines are too good at doing exactly what you said.

The skill is open-source. Install it. Use it. Stop burning tokens on goals you haven’t actually defined.

Your agent isn’t the problem. Your instructions are.