Dev Blog #3: Token Economy

Generative AI has made it possible for me to attempt a project like StormTome on my own. Much of the early code and artwork was done with Layers and GPT-5.6. Then GPT-6 Astra arrived, and development accelerated considerably. The artwork has been excellent, and ideas that previously needed several rounds of correction are coming together much more quickly.

Unfortunately, my usage allowance is disappearing much more quickly too. Alongside development time, I now have another resource to manage: tokens.

The Golden Year

For a while, $20 a month bought an amount of AI-assisted work that seemed worth far more than the subscription. Whatever limits existed, they rarely felt like the main obstacle. I got used to that.

GitHub's April 2026 changes to Copilot usage limits made the shift difficult to ignore. For the way I was using it, Copilot felt like a shadow of its former self. I moved to Codex, where the $20 monthly plan still offered good value.

By the summer, the five-hour usage window was getting in the way. Sometimes I could do roughly thirty minutes of intensive development and then spend much of the remaining window waiting. I eventually moved to the $100 plan so I could keep working.

Astra Has Entered the Chat

When Astra was release, it represented a significant leap in coding capabilities, but at a significant cost. On average, I could consume a week's allocation in two days. I wanted Astra's better results, but I also wanted enough usage left to finish the week.

Looking through the available usage records with Astra pointed to substantial repeated work around testing. The agent was writing hundreds of unit tests, running large collections of them, and reading the output. Some of that was my fault. My AGENTS.md instructions encouraged extensive testing without saying how much a particular change needed. I had asked for thoroughness, and I was getting it.

We introduced smaller smoke suites covering the main flows, with directly affected tests for small changes and broader verification for larger ones. The local tests themselves do not consume model tokens while running, but the agent's work around them does.

What Does a Week Buy?

If you look at OpenAI's pricing plan, you'll see mention of “Expanded Codex usage”. This particular wording is difficult to translate into a development schedule. A small edit and a long investigation can use very different amounts of the allowance. A percentage tells me how much I have used, but not how many features I can finish before it runs out.

In September, usage disappeared much faster than I expected. Additional credits let me continue, but in my experience they are expensive and disappear quickly too. Planning a week around that uncertainty has become part of the job. Had OpenAI not repeatitly reset usage in October, Codex would have been unusable.

Spending Less on the Work Around the Work

With a some research, I found several improvements I could do to extend the value of my credits. For example, I had been carrying conversations across unrelated tasks, bringing old discussions into each new piece of work. That history can include files, tool output, and decisions that no longer help with the current problem. Now I prefer a fresh session when I change topics, with a clear task and the relevant background. For the same problem, keeping useful context can save the agent from discovering everything again.

Project instructions needed attention too. We shortened StormTome's root AGENTS.md from about 8.4 KB to 4.6 KB while keeping the important rules. More useful still was deciding when to load supporting documents. A question about damaging a monster needs the combat rules. It does not need coding standards or every screen description in the UI guide. Detailed procedures can live in separate guides, with a short instruction telling the agent when to read them. Otherwise, a rule written for one particular task becomes baggage for every task after it.

We applied the same idea to tool output. Orignally, agents were ready every logs of unit tests. Now, tests and builds write to temporary logs. The agent will read the summary at first and only looks at the details when something fails. The full output is still available, but a successful test run does not need to fill the conversation with hundreds of lines.

Another significant source of token uses where third party libraries, which should normally be ignored in ordinary searches. We found that small maps in the READMEs help the agent find the relevant code without reading every file in the project. Hence, the context search can start with the function or section involved, then follow callers and related code, and uses the maps in READMEs as the investigation requires.

Unfortunately, given the ambiguity of the measuring system, none of this gives me an exact improvement of the allowance I'll get on my plan. Shortening an instruction file by 46% does not mean saving 46% of my usage. It does help keep the agent's attention on the work I actually need done, and that should translate into savings.

I still want to use the more capable models. Astra has made a real difference to how quickly StormTome is taking shape. Getting the most out of it has also meant learning to manage the instructions, context, and checks that come with every edit.