DEV Community

Avery Lin
Avery Lin

Posted on

Shipping on a 10M-Token Budget

#ai #programming #productivity #opensource

Shipping on a 10M-Token Budget

A solo founder pushed a fix at 2 a.m. The test suite passed. The monthly bill was zero dollars. That moment is the reason free tiers matter.

The fragility has a name. Token math. Every AI generation spends from a monthly allowance. Ten million tokens sounds generous. One large refactor can burn hundreds of thousands in a single session.

MonkeyCode is an open-source coding assistant with free model access and a free server option. Disclosure: This article was prepared as part of MonkeyCode's product outreach. The current free tier includes a 10M-token allowance. Terms change, so verify them in the project docs before relying on them.

Think of the allowance as a pantry. A month of meals must come from one shelf. Cook a feast on day one, and day twenty is instant noodles. Budget before cooking, not after.

The core discipline is test-first generation. Write the failing test before the model writes the code. The test is the contract. The model fills the implementation. While the model generates, the founder writes the next test. That is the answer to the empty moment. The reviewer is busy defining the contract.

Here is the workflow in practice. A small feature arrives. The founder writes a failing test.

// feature.test.js
import { describe, it, expect } from 'vitest'
import { applyDiscount } from './cart.js'

describe('applyDiscount', () => {
  it('caps the discount at 20 percent', () => {
    expect(applyDiscount(100, 0.5)).toBe(80)
  })
})
Enter fullscreen mode Exit fullscreen mode

The test fails. That is the point. Now the prompt has a target. Send the failing test to the model. Ask for the smallest implementation that makes it green.

The second half of the discipline is the token budget. Every generation gets recorded. The remaining allowance stays visible. The script below is the artifact.

#!/usr/bin/env bash
# token-budget.sh — record one generation, print the month's total
LEDGER="${LEDGER:-$HOME/.monkeycode/token-budget.csv}"
MONTH="$(date +%Y-%m)"

[ $# -lt 3 ] && {
  echo "usage: token-budget.sh <prompt_tokens> <completion_tokens> <task>"
  exit 1
}

mkdir -p "$(dirname "$LEDGER")"
[ -f "$LEDGER" ] || echo "date,month,prompt,completion,total,task" > "$LEDGER"

total=$(( $1 + $2 ))
echo "$(date -u +%Y-%m-%dT%H:%M:%SZ),$MONTH,$1,$2,$total,$3" >> "$LEDGER"

awk -F, -v m="$MONTH" '
  NR > 1 && $2 == m { p += $3; c += $4 }
  END {
    printf "month: %s\nprompt: %d\ncompletion: %d\ntotal: %d\n", m, p, c, p + c
  }
' "$LEDGER"
Enter fullscreen mode Exit fullscreen mode

Wire it into the daily flow with a wrapper. Replace mc with the real command name. The exact field names depend on the tool. Adjust the parsing to match the real output.

mc() {
  out=$(command mc "$@")
  p=$(printf '%s' "$out" | jq -r '.usage.prompt_tokens // 0')
  c=$(printf '%s' "$out" | jq -r '.usage.completion_tokens // 0')
  token-budget.sh "$p" "$c" "$*"
  printf '%s\n' "$out"
}
Enter fullscreen mode Exit fullscreen mode

A budget check keeps the month honest.

ALLOWANCE=10000000
used=$(awk -F, -v m="$(date +%Y-%m)" 'NR > 1 && $2 == m { p += $3; c += $4 } END { print p + c }' "$LEDGER")
echo "remaining: $(( ALLOWANCE - used )) tokens"
Enter fullscreen mode Exit fullscreen mode

Three gates stand before every generation. The first gate is speed. If the edit is faster to type, type it. The second gate is context. The task must fit the model's window. The third gate is verification. A test or a type check must confirm the output. If all three gates open, spend the tokens. If any gate closes, do the edit by hand. The gates are what make the allowance last.

Verification comes right after generation. Run the test. Read the diff. Merge only when the test passes and the diff reads clean.

npm test
git diff --color=always | less
Enter fullscreen mode Exit fullscreen mode

The free server is the second half of the zero-dollar month. It hosts the small product while the tests run locally. A landing page, a bot, a cron job. It is not a platform for a paid SLA. Expect cold starts and modest limits. Accept the limits and move on.

Deploying is a push, not a ceremony.

git push origin main
curl -s https://your-app.example/health
Enter fullscreen mode Exit fullscreen mode

The first week, the budget told a harsh story. A thousand-line refactor consumed the allowance in three sessions. The fix was not a bigger model. It was smaller prompts. Break the refactor into steps. Each step gets its own test and its own generation.

AI promoted every developer to reviewer. A solo founder is the reviewer with no backup. The test is the only colleague that never sleeps.

This workflow is not for everyone. Teams with compliance requirements should skip it. Products with hard latency targets should skip it. Anyone with unpredictable token usage should skip it. The free tier is a constraint, not a strategy. It works when the constraint is the point. A solo founder can make that trade. A bank cannot.

The 2 a.m. fix is repeatable. Write the test. Spend the tokens. Verify the diff. Keep the bill at zero. The free tier is open, and the budget script is in this post. A zero-dollar month is a good month to ship something small.

Top comments (0)