# Why AI budgets could make you a better engineer

For the past year, many engineers worked as if AI were unlimited. Ask, retry, ask again. Use the biggest model for everything. Let an agent run and see what comes back.

That era is ending, and I think it might make us better engineers.

## What changed

As AI bills grew, companies started putting limits in place.

[Uber capped spending on AI coding tools such as Claude Code and Cursor](https://www.silicon.co.uk/workspace/uber-ai-caps-630085) at $1,500 per month for each tool, after going over its annual AI budget earlier this year. Staff can ask to go over the cap, and each employee can track their usage on a dashboard.

[Tesla told staff it would cap AI spending at $200 per week](https://electrek.co/2026/07/02/tesla-caps-employee-ai-spending-200-week/) starting in July, with approval needed to go higher. According to people familiar with usage, some software engineers had been using thousands of dollars' worth of tokens each week.

[Amazon took down an internal leaderboard](https://www.cio.com/article/4178825/amazon-deletes-devs-tokenmaxxing-leaderboard-to-minimize-costs-2.html) that ranked employees by how much they used its Kiro AI tool, after managers found people building unnecessary AI agents just to climb the rankings.

That last one says a lot. For a while, heavy AI usage was treated as a sign of productivity, a trend people started calling "token maxxing." But more usage doesn't mean more value, and finance teams noticed.

AI is becoming a budgeted resource, like cloud spend.

## Engineers have always worked with limits

This isn't new. Engineers have always built within limits: memory, CPU, network bandwidth, storage, cloud budgets. Much of what we call good engineering is simply getting the most out of what you have.

Unlimited AI was the unusual part. It let us skip questions we would normally ask: Is this the right tool for the job? Is there a simpler way? Is this worth the cost?

A budget brings those questions back.

## Where the cost actually comes from

Before changing any habits, it helps to understand what you're paying for. Most people never look, because when usage is unlimited, there's no reason to.

**Tokens.** AI models read and write text in small pieces called tokens. A token is roughly a short word or part of a longer one. You pay for the tokens the model reads (your input) and the tokens it writes (its output). With most providers, output costs more per token than input.

**Context is reread every time.** In most chat tools, each new message sends the whole conversation so far back to the model, along with any files you attached. A short question at the end of a long conversation can cost far more than the same question asked fresh. Some tools reduce this with caching, but long, messy conversations are still one of the biggest sources of hidden cost.

![Chart showing each new chat message sending the whole earlier conversation back to the model, so cost grows with every message](https://cdn.hashnode.com/uploads/covers/6ae2357e62c905be58cc0f26/4266387d-6946-4efa-8a4f-02b2aa8b65f4.png align="center")

*Diagram created with AI assistance*

**Model choice multiplies everything.** The most powerful models can cost many times more per token than smaller ones. The same task, with the same prompt, can cost very different amounts depending on which model you pick.

**Agents compound all of it.** An agent doesn't make one request. It plans, calls tools, reads results, and tries again, often dozens of times for a single task. Each step rereads the growing context. That's why an agent left running on a vague task can burn through a budget much faster than any amount of chatting.

Once you see costs this way, the wasteful habits become obvious.

## The habits that limits expose

Limits only hurt when the habits behind them are wasteful. A few habits that grew during the unlimited period:

- Retrying the same prompt again and again instead of stopping to think
- Using the most powerful model for every task, even small ones
- Loading huge amounts of code or text into context "just in case"
- Letting agents run long tasks without checking whether they're getting anywhere
- Asking AI to do things that would be faster to do yourself

None of these feel expensive in the moment. Together, they are where most of the cost goes.

## How to work smarter with AI on a budget

### Match the model to the task

A small, fast model is fine for simple questions, quick edits, formatting, and summaries. Save the most powerful model for problems that genuinely need it: tricky debugging, design decisions with many trade-offs, or code you don't understand yet.

For example, renaming variables across a file or turning notes into a clean list doesn't need your most capable model. Figuring out why a system fails only under heavy load probably does.

A simple rule: start small, and move up only when the smaller model can't do the job.

### Think first, prompt once

A short plan or a clear description of what you want usually beats five vague attempts.

Compare these two requests:

- "Fix this function."
- "This function should return the total price including tax, but it returns the price without tax when the cart has more than one item. Here's the function and one failing example."

The second takes thirty seconds longer to write and often saves several rounds of back and forth. The thinking you do up front saves the tokens you would spend correcting.

### Give the right context, not all of it

It's tempting to give the AI everything "just in case." But more context isn't always better. It costs more, and it can make answers worse by burying what matters.

Point the AI to the specific files, functions, or details that matter. If you're asking about one function, share that function and what it depends on, not the whole project.

When a conversation gets long and messy, start a fresh one. Write a short summary of where you are and what you've learned, and continue from there. It's cheaper, and the model often does better with a clean start.

### Stop the loop early

If two attempts haven't worked, the problem is often the question, not the answer.

This is where a lot of budget quietly disappears: asking the same thing a third, fourth, and fifth time with small changes, hoping the next answer will be right. Instead, step back. Is the requirement clear? Is something missing from the context? Is AI even the right tool for this part?

Five minutes of your own thinking is often worth more than five more attempts.

### Keep agents on a short leash

Agents are powerful, and they're also where costs can grow fastest. A few habits help:

- Give them a clear, narrow goal instead of an open-ended one.
- Check in on long tasks instead of letting them run unattended.
- Break big jobs into smaller steps you can review.
- If an agent is going in circles, stop it and rethink the task.

An agent that finishes a small, well-defined task is worth far more than one that runs for an hour on a vague one.

### Spend AI where it has the most leverage

Not every task benefits equally from AI. High-value uses include:

- Understanding unfamiliar code or a new library
- Generating test cases you might not think of
- Reviewing a design and pointing out gaps
- Drafting documentation from existing code

Lower-value uses include small changes you already know how to make, or tasks where explaining what you want takes longer than doing it yourself.

### Reuse what works

If a prompt or set of instructions gives good results, save it. Build a small library of templates for things you do often: reviewing a pull request, writing tests, explaining an error.

Rewriting the same instructions from scratch every time costs effort and often produces worse results than a version you've already refined.

Some tools take this further. Claude, for example, supports "skills": saved sets of instructions for specific tasks that the model loads only when a task needs them. Instead of paying to send the same long instructions with every request, you write them once and they're used only when relevant.

### Know your own usage

If your tool shows usage, look at it once in a while. Which sessions used the most? Which tasks? It's often a few long conversations or agent runs, not your everyday work.

You can't improve what you don't look at.

### Keep your own skills sharp

The engineers who handle limits best are the ones who can still think through a problem without AI. Reading code carefully, debugging step by step, and designing before building are skills that make every AI request better, and cheaper.

## What not to cut

Budgets can push people too far the other way: avoiding AI even where it clearly helps, just to save a few dollars.

That's a mistake too. The goal isn't to use less AI. It's to use it where it pays off. A good test is to ask: did this save me more time than it cost? If an AI-generated test catches a bug before it ships, it was worth every token. If you asked the same question six times, it probably wasn't.

## Why this makes us better

Every one of these habits is just good engineering: choosing the right tool, thinking before acting, focusing on what matters, knowing when to stop. Unlimited AI let us get away without them. Budgets bring them back.

The engineers who come out ahead won't be the ones who used the most AI. They'll be the ones who used it best.

## What I'll be exploring next

This post is the start of a short series on getting real value from AI when it isn't unlimited.

The habits above apply at work. But budgets matter outside work too. When you build side projects, every token comes out of your own pocket, and API bills add up fast.

One option I want to explore for personal projects is running a small open-source model yourself. Not for everything, but for simple tasks you repeat often, like sorting text into categories, pulling out specific details, or reformatting data. These don't need the most powerful model, and paying per token for them adds up over time.

If an open model gets close but not quite there, fine-tuning it on your own examples can make it better at that one narrow job. That takes time and effort, so it's only worth it when the task repeats often enough to pay back the work.

I'll look at when this makes sense, what it really costs, and when paying for a hosted model is still the better choice.

How are you handling AI costs, at work or on your own projects? I'd like to hear what's working.

## Sources

- [Silicon UK: Uber sets AI coding usage caps to cut costs](https://www.silicon.co.uk/workspace/uber-ai-caps-630085)
- [Electrek: Tesla caps employee AI spending at $200 a week](https://electrek.co/2026/07/02/tesla-caps-employee-ai-spending-200-week/)
- [CIO: Amazon deletes devs' tokenmaxxing leaderboard to minimize costs](https://www.cio.com/article/4178825/amazon-deletes-devs-tokenmaxxing-leaderboard-to-minimize-costs-2.html)