Jack Franklin has been using Claude Code as a pair programmer, debugger, and feedback collector while developing his game OnTrack (internally called routemaster). The setup worked so well that he ended up building a custom skill to scale the workflow—and in doing so, discovered just how expensive unstructured AI loops can get when you're not paying attention to token costs.

The Markdown Bottleneck

Franklin's playtesting workflow started simple: he'd spend an hour playing his game, note bugs and suggestions as Claude helped collate them into a markdown file. Claude proved adept at deduplication and categorization—grouping issues under UI, mechanics, or "quick wins" headings. But as fixes accumulated, the files ballooned. One day he realized his incomplete feedback document had hit 3,000 lines, with another 4,000 lines of completed items in a separate file. The real problem wasn't storage—it was that Claude had to read entire files even when Franklin only wanted to query a subset: listing high-priority bugs or filtering by category required parsing everything first.

Structured Storage With SQLite

The solution was a Deno CLI backed by SQLite—a database schema with title, detail, priority, status, category, project, and done flags. Completed items stay in the table but hide from default queries, preserving full history without forcing Claude to parse stale data on every request. Franklin built it in Deno ("because I wanted to try building something in it") though he notes Node or any other runtime would work fine—Claude wrote most of it anyway. The CLI lets you run add with project flags, show specific IDs for details, and done to mark items complete without deleting them from the database.

Token Optimization Strategies

The skill file teaches Claude how to use the CLI efficiently, and some guidance proved more valuable than others. Always list before show: titles and IDs consume far fewer tokens than full descriptions, so there's no point listing item details by default—that defeats the entire purpose of moving away from markdown files. Another win was inferring project context rather than asking every time; Claude figures out which project you're working in from conversation history and only prompts when genuinely ambiguous. The duplicate detection hint also paid off—Franklin found himself describing the same underlying issue two different ways without realizing it, and Claude catches that before items get stored.

Key Takeaways

  • AI feedback loops have hidden token costs when using unstructured formats like Markdown for long-term projects
  • SQLite provides structured queries that let LLMs access only the data they need, dramatically reducing context overhead
  • Designing skills with "list before show" patterns prevents unnecessary token consumption on detail reads
  • Context inference reduces back-and-forth prompting, saving tokens across entire sessions
  • Completed items don't need to disappear—they just need to be hidden from default queries

The Bottom Line

This isn't just clever dev tooling—it's a blueprint for anyone building AI-assisted workflows at scale. If you're feeding long documents into LLMs and wondering why your costs are climbing, the answer is probably staring you in the face: you're reading everything when you only need something. Structured storage with smart querying patterns isn't optional overhead—it should be step one.