The $20 Detox (Part 1): The Infinite Token Hangover

The (Seemingly) Unlimited tokens were exhilarating, revolutionary, ego-massaging, world changing and … unsustainable

1. The Speed Trap

With an unconstrained AI Pro account, building software felt ridiculously fast at first. My creativity was unconstrained. I could think it, build it and ship it … rinse … repeat.

I could spin up whole features in minutes. The database schema, Express router, React dashboard. The model wrote hundreds of lines of working TypeScript without breaking a sweat. I didn't worry about token limits or context size. If something broke, I would paste the error into the chat, the model would replace the code, and everything would turn green again. If I saw a bug, I took a screenshot and pasted it. While I initially looked at the code, eventually I just switched to telling the agent what I wanted it to do because review and resolve was slowing me down.

For weeks, I moved at what felt like 20x velocity. I was building an operations and quality intelligence platform for a 24x7 global network of support experts.

And it wasn't just a basic CRUD app; it had genuinely cool, complex features that felt like magic to build:

The Response Assistant: An in-app AI copilot for support engineers that read active customer conversations and drafted technical responses in real time.
Natural Language Reporting: You could type questions in plain English, and the backend would dynamically generate SQL queries against the database, scrub customer PII, run the query, and have AI narrate the insights back.
Automated QC & CES Predictor: An automated evaluation engine that analyzed full ticket transcripts against custom quality rubrics to predict customer experience scores (CES) and flag bad habits (like premature resolves or brush-offs) before the customer even received a survey. Oh, the joy of tweaking the prompts, weights, and rubrics to get just the right prediction.
Vendor & Hiring Pipeline: A dedicated portal where external vendors submitted candidates directly into an interactive hiring kanban, automatically triggering guest invites via email and assigning taxonomy-based skill tags.
Global Availability & Squad Heatmaps: Live monitoring of squads across time zones, tracking active ticket pickup velocity, shift handovers, and SLA breach countdowns.

On the surface, the app was impressive. It had rich dashboards you could click down to the individual message level, live rosters, automated quality grading on distinct patterns, and complex filters.

Then real operations leads, team managers, and staff started using it every day.

2. The 2,500-Line Monolith and the Copy-Paste Machine

As soon as the platform hit production, the cracks appeared.

The first dose of reality was real users! In my perfect bubble of AI led product development, where the user experience research had also been offloaded to AI, an AI trained on global common patterns gave me about 70 - 80% of what I need out of the box, but also missed the critical 10 - 15% that would make the product a habit. There also were the idiosyncrasies of users that wanted to continue to work a certain way, despite having a better tool in hand that would allow then to operate in a more efficient way. These weren’t major but it was a useful lesson gently bringing me back a bit closer to earth.

Because also AI had no global architectural discipline (I thought it was doing a fine job because the UI looked great and everything worked!) it solved every new bug by taking the path of least resistance: patching only the file right in front of its nose, or the exact use case I pointed it to without thinking of the impact.

Over 300 commits, this pattern quietly wrecked the codebase:

Monolithic files exploded: Without strict modular boundaries, routers and pages bloated uncontrollably.
Logic was copy-pasted everywhere: Instead of creating reusable abstractions, AI simply re-wrote identical code in new places. We had the exact same UUID code copy-pasted 7 separate times, file-download logic written 8 separate times, and dropdown pickers duplicated across multiple pages.
Hand-rolled queries: Across 9 different routers, there were 60 separate call sites where AI hand-rolled custom SQL WHERE clauses to check if a manager was allowed to see their squad's tickets. Each one was slightly different.
Seven role-gate security audits: Because AI lacked system-wide memory, it constantly added new API endpoints and forgot authorization checks. Any logged-in user could hit sensitive routes. I had to run seven separate security sweeps just to catch missing requireRole and scopeToSquad guards.
State machine deadlocks in production: In one incident, an expert marked "Skill Failed" was moved toward offboarding, retook and passed the test, but got permanently stuck in the UI stepper because two conflicting validation rules blocked the back button. I had to (tell AI to) write a one-off database patch script just to fix their record live in production.
Silent data loss: In an upload cleanup script, AI wrote retention pruning logic that accidentally deleted historical ticket records because it didn't understand the cascade relationship between upload batches and ticket data.
Clean Slate: Not to mention the time 3 weeks in where I experimented with AI running the git repository and it deleted 3 weeks of code!

The app worked, but it was quicksand. Every bug fix was a localized patch that made the overall system more fragile.

And yet, amid the quicksand, it would be wrong to dismiss the experiment as a failure. The positive outcomes were massive:

Solo Enterprise Delivery: I Conceived, built, and shipped an operations and quality intelligence platform supporting a 24x7 global support operation in under 2 months, solo. Owning Product, Dev, QA, and DevOps, I delivered a footprint that would traditionally require a cross-functional team of 6 to 8 people across multiple quarters.
Real Daily Adoption: The platform wasn't an internal toy or weekend demo. Real operations leads, managers, and support engineers used it every day. It automated hours of manual quality audits, removed hiring and onboarding friction, and gave leadership instant visibility into live squad performance.
Unprecedented Feedback Agility: When frontline operations needed a workflow shift, I didn't write tickets for a future sprint. I tweaked the schema, iterated the UI, and shipped working production software that afternoon.
The Core Validation: The experiment proved pure AI-driven delivery is genuinely viable for mission-critical enterprise workflows. The friction wasn't evidence that AI couldn't build software: it was proof that synthetic velocity without classical architecture creates an unsustainable token tax.

3. The Compounding Token Tax

This is where the token problem became lethal.

When a codebase is modular and well-structured, a prompt only needs a small, focused slice of context. But when I had 2,500-line monolithic files, 60 hand-rolled query variations, and duplicate components, I had to feed thousands of lines of messy code into the prompt just to explain a simple bug.

[Bloated Codebase] ──> Needs massive files in prompt context
       ▲                                                    │
       │                                                    ▼
[AI Forgets Instructions & Hallucinates] <── [Context Window Saturated]

Early on: Prompts were small (under 1,000 tokens). AI was sharp, accurate, and focused.
At 100 commits: To fix a routing issue, I had to paste an entire 2,000-line router and three related types files. Prompts exploded past 40,000 tokens.
At 250 commits: The chat window was choking. AI suffered from attention dilution. It would follow the first two lines of a prompt, forget the edge cases at the bottom, hallucinate imports, and break working features on the other side of the file.

I was burning through massive token allowances every single day, not because the features were hard, but because I was paying a heavy tax to feed AI its own unmanaged technical debt. But, I could not stop. I was this close.

4. The $20 Constraint

I was talking through my challenges with a friend. I was talking to him about the additional guardrails, rules and context I had started putting in to keep AI from breaking its own code.

His advice:

"You have an infinite token problem. When your token budget is unlimited, you just throw more context at the model. Cancel your Pro tier. Downgrade to the basic $20 account. Put yourself on a token starvation diet."

His point was clear: If my code required 50,000 tokens of context to safely make an edit, my architecture was broken.

A tight token budget forces me to spend more time on the spec, the outcome which leads to smaller modular files, clean public interfaces, and strict boundary rules. If a file is too big to fit comfortably in a cheap prompt, the file is too big.

I downgraded to the $20 tier, took the hard lessons from that first platform, and started a brand new project from scratch.

That project was NyayTech: a practice management platform for Indian law firms.

5. Over-Correcting with Specs

Starting with a clean slate and strict token limits, my instinct swung completely to the opposite extreme.

I told myself:

"The mistake on the first platform was letting the AI write code before things were properly structured. This time, I will not let it write a single line of code until everything is specified down to the pixel."

Before writing any implementation code, I decided to "spec the hell out of it":

Drafted detailed user stories for all 12 epics across the app.
Wrote huge markdown rulebooks detailing every architectural invariant, design token, and coding standard.
Built an 8-persona review council into the prompt (Senior Advocate, Clerk, Litigant, QA, Spatial Auditor, Architect) to evaluate every screen.

On August 15, 2026, I started the repository with 51 story specifications and pages of markdown rules.

It felt like peak engineering discipline.

What I didn't realize was that I had just walked straight into another trap, one that would teach me how LLMs actually process constraints.

(Next in Part 2: The Spec Over-Correction: I still ate my entire token budget, and why models ignore simple English instructions.)