Tokens Are a Metric: Proper Usage

# Tokens Are an Optimization Metric, Not Something to "Burn on Full Blast"

## The Childish Advice Everyone Repeats

"Don't save tokens. Burn them to the max. While subscriptions are cheap, go full blast. This is the Wild West — you need to experiment."

This is a quote from Sheiko's lecture. Every second "AI implementation expert" repeats the same thing. It sounds bold. It sounds like "I'm not afraid to spend the company's money." It sounds like a position.

In practice, this is **childish advice**. Because it ignores a fundamental truth: **tokens are not gasoline to be burned. Tokens are context that the agent processes**. And the more context, the worse the agent performs.

More tokens ≠ better. Often the opposite.

---

## Why Bloated Context Hurts

Every token in the context window is information the agent must process. Not "read and forget." **Process**. Hold in attention. Connect with the other tokens.

Here's what happens when context gets bloated:

**1. Attention gets diluted.** The agent starts "losing the thread." Important instructions drown in a wall of text. The agent latches onto random fragments instead of following the goal.

**2. Compaction is inevitable.** The context window is finite. Bloated context hits the limit faster. The agent does compaction — compresses the history. During compression, **information is lost**. Not "almost nothing is lost," as optimists claim. Nuances, edge cases, implicit constraints are lost. After compaction, the agent starts doing things you explicitly forbade three messages ago.

**3. Speed drops.** More input tokens — slower inference. It's not a linear relationship. Attention is quadratic complexity. Bloated context slows down every step the agent takes.

**4. Cost goes up.** Obviously, but not everyone calculates this. If the agent eats 200k tokens for a task solvable in 50k — you pay 4x more. Not for a better result. For a worse one. Because bloated context produces worse results.

---

## Prompt Conciseness Is Not About Saving. It's About Quality.

A concise instruction works **better** than a wall of text. Not because "we're saving tokens." But because:

**1. The agent understands the task precisely.** When the instruction is 200 tokens instead of 2,000, the agent doesn't guess what matters. Everything matters. Everything is in focus.

**2. Fewer contradictions.** In a 2,000-token wall, contradictions are inevitable. "Do X" in paragraph 3, "don't do X" in paragraph 17. The agent chooses randomly. In a concise instruction, there are no contradictions.

**3. Fewer hallucinations.** Bloated context prompts the agent to "make up" connections between fragments that don't exist. Concise context leaves no room for fabrication.

**4. Skills scale.** A concise skill can be handed to a sub-agent and it will understand it. A 5,000-token wall — the sub-agent won't digest it. It'll lose half and do its own thing.

---

## English Is More Compact Than Russian

This is not an opinion. It's tokenization math.

In most tokenizers (BPE, SentencePiece, used in GPT, Claude, LLMs) **English text takes fewer tokens per character** than Russian. Why:

- English alphabet: 26 letters. Frequent bigrams and trigrams compress well into tokens.

- Russian alphabet: 33 letters + Cyrillic. The tokenizer breaks Russian words into more sub-tokens.

- Average English token: ~4 characters. Average Russian token: ~2-3 characters.

What this means in practice:

English prompt: "Write a function that parses JSON and validates required fields" — ~15 tokens.

Same prompt in Russian: "Напиши функцию, которая парсит JSON и валидирует обязательные поля" — ~20-25 tokens.

A 30-40% difference. At project scale, where the agent processes hundreds of prompts per day, this is a **significant difference in speed and quality**.

Sheiko says in the lecture: "Write in Russian because you'll provide much more context." This is **incorrect**. Russian gives more characters, but not more useful context. It gives more tokens for the same thought. And more tokens is not more context. It's more noise.

If you want to give the agent more **meaningful** context — give more information, not more characters. Concisely. In English.

---

## Don't Bloat the Current Task Context

One of the biggest mistakes is dumping **everything that might be useful** into context. "What if the agent needs this file? What if this commit history? What if this three-year-old comment?"

No. It won't need it. And even if it does — the agent will request it via tools (grep, AST search, file reading). Don't pre-fill the context as a precaution.

**The rule:**

The task context should contain only what is **directly needed for the current step**:

- Task description (concise)

- Completion criteria (concise)

- Relevant files (only those the agent is reading right now)

- Rules and constraints (concise)

Everything else — in tools. The agent will fetch it when needed. Don't turn context into a "dump for just in case."

---

## Tokens as an Optimization Metric

Tokens are not something to "burn." They are a **cost/quality ratio metric** that should be analyzed.

**What to log:**

```

Task | Input Tokens | Output Tokens | Iterations | Rework? | Result

A    | 45k          | 12k           | 3          | No      | ✅

B    | 180k         | 35k           | 11         | Yes     | ❌

C    | 52k          | 15k           | 4          | No      | ✅

D    | 200k         | 40k           | 14         | Yes     | ❌

```

**What to analyze:**

1. **Tasks with high token consumption and rework** — a signal that context is bloated or the prompt is not concise. Optimize the prompt, remove excess from context.

2. **Tasks with low token consumption and no rework** — a success pattern. Scale it. Turn these into skills.

3. **Number of iterations** — if the agent does 11+ iterations, it's "stuck." Most likely the context is contradictory or the feedback loop isn't closed.

4. **Input/output ratio** — if input is 200k and output is 40k, 80% of the context was noise. The agent "digested" it but didn't use it.

---

## Practice: How to Optimize

**1. Concise system prompts.**

Don't write a 3,000-token wall. Write 300 tokens that contain only:

- Agent role (1 sentence)

- Quality criteria (3-5 points)

- Constraints (3-5 points)

- Output format (1-2 sentences)

**2. Modular skills.**

One skill = one task. Not a "universal skill for everything." A concise skill for a specific task works better than a mega-skill for everything.

**3. On-demand context.**

Don't pre-fill context. Give the agent search tools (grep, AST search, file reading). Let it fetch what it needs, when it needs it.

**4. English for prompts.**

Instructions, system prompts, skills — in English. More compact, fewer tokens, faster inference. Domain-specific terms can stay in Russian if they're specific.

**5. Logging and analysis.**

Every session gets logged. Once a week — analysis: which tasks burn lots of tokens and cause rework? Optimize prompts for those tasks.

---

## "Burn Tokens" — Advice for Those Who Can't Count

When an "expert" says "burn tokens while they're cheap" — it means they can't:

- Write concise prompts

- Set up modular skills

- Log and analyze cost/quality

- Optimize context

They compensate for lack of skill with volume. They dump walls of text into the agent and hope that "more is better." Not better. Worse.

A company that "burns tokens on full blast" in a month gets:

- An API bill 3-5x higher than it could be

- Agents confused in bloated context

- Compaction every 5 minutes with information loss

- Rework on 30-40% of tasks

- A team burned out from sorting through results of agents that "forgot" instructions after compaction

A company that **optimizes tokens** in a month gets:

- An API bill within budget

- Agents that precisely follow concise instructions

- Minimal compaction

- Rework on 5-10% of tasks

- A team that verifies results in minutes, not hours

---

## Conclusion

Tokens are not gasoline. They are context. And context should not be "burned" — it should be **optimized**.

Concise prompts work better than walls of text. English is more compact than Russian. Bloated context hurts the agent. More tokens ≠ better results.

"Burn tokens on full blast" is childish advice for those who can't count cost/quality ratio. The mature approach — log, analyze, optimize. And understand that **the best prompt is one where not a single token is wasted**.