DEV Community: justin li

How I Built a Unified Cost Tracker for AI Coding Agents (Claude Code, Cursor, Codex)

justin li — Thu, 06 Aug 2026 02:33:23 +0000

How I Built a Unified Cost Tracker for AI Coding Agents

AI coding agents are amazing — until the bill arrives. And it will arrive from three places at once: Claude Code in one directory, Cursor in another, Codex in a third. Each logs usage in its own JSONL format, with different field names and different pricing models.

So I built a small local tool that reads all three, normalizes them, and produces one cost report — by model, by day, by agent — with budget guardrails that warn at 80% and flag at 100%. Here's what it took.

The Hard Part: Three Different Log Formats

Each agent logs usage differently:

// Claude Code — usage nested under message, with cache fields
{"type":"assistant","message":{"model":"claude-sonnet-4-20250514",
  "usage":{"input_tokens":523,"output_tokens":187,"cache_read_input_tokens":1200}},
 "timestamp":"2026-08-01T10:00:00.000Z"}

// Codex CLI — usage nested under payload
{"type":"response_item","payload":{"type":"message","model":"gpt-5-codex",
  "usage":{"input_tokens":2000,"output_tokens":800}}}

// Cursor — different field names entirely
{"type":"assistant","message":{"model":"gpt-4o",
  "usage":{"prompt_tokens":800,"completion_tokens":300}}}

The parser can't assume a shape. Instead of three hand-written parsers, I wrote one recursive extractor that walks the object tree, finds any usage object, and pulls the tokens with fallbacks:

function extractUsage(obj, out, parentTs) {
  if (!obj || typeof obj !== 'object') return;
  if (obj.usage) {
    out.push({
      model: obj.model || obj.message?.model || '',
      inputTokens: obj.usage.input_tokens ?? obj.usage.prompt_tokens ?? 0,
      outputTokens: obj.usage.output_tokens ?? obj.usage.completion_tokens ?? 0,
      cachedReadTokens: obj.usage.cache_read_input_tokens ?? 0,
      ts: parentTs || obj.timestamp || ''
    });
    return;
  }
  for (const k of Object.keys(obj)) {
    if (['usage','message','payload','request'].includes(k)) {
      extractUsage(obj[k], out, obj.timestamp);
    }
  }
}

That handles all three formats (and future ones) with one code path.

The Pricing Engine: 23 Providers, Cache Discounts

The real insight: you don't need per-model accuracy to be useful — you need good enough to spot runaway spend. I reuse a pricing table of 23 providers (Anthropic, OpenAI, DeepSeek, Google, etc.), match by exact name or prefix, and fall back to a provider-name guess for unknown models:

function estimateCost({ model, inputTokens, outputTokens, cachedReadTokens = 0 }) {
  const price = lookupModel(model);          // $/1K tokens
  const cached = Number(cachedReadTokens) || 0;
  // cache reads are ~10x cheaper than fresh input
  const cost = (inputTokens * price.input
              + cached * price.input * 0.1
              + outputTokens * price.output) / 1000;
  return { cost, estimated: !!price.estimated };
}

Unknown models get an estimated rate (flagged in the report), so nothing silently disappears from the total.

Budget Guardrails

The killer feature isn't the report — it's the limit. Set a monthly budget, and the tool tells you where you stand:

< 50% — OK
≥ 80% — WARN (you'll overspend at this rate)
≥ 100% — OVERRUN

Guardrail: $0.0698 / $50 (0%) → OK

Two Forms: CLI + MCP

Developers live in terminals, but agents live in the MCP ecosystem. So the tool ships as both:

CLI: agentcost scan ~/.claude/projects 50 → terminal report
MCP server: exposes scan_cost, get_budget, set_budget tools — so your coding agent can answer "how much have I spent this month?" itself

What I Learned

Field-name drift is the real cost — input_tokens vs prompt_tokens vs inputTokens. One recursive extractor beats three parsers.
Cache accounting matters — Claude's cached reads are ~10x cheaper; ignoring them overstates costs badly on long sessions.
Estimates beat silence — an unknown model that shows up as "$0" teaches users to ignore the tool. Flag it as estimated instead.
Local-first is a feature — "nothing leaves your machine" is a privacy story users actually care about, especially for cost data.

Status

The project is in early release (v0.1, 22/22 tests passing) and available on npm: agentcost-cli. This is my first open-source tool from the SellerTools family, and I'm looking for feedback from heavy Claude Code / Cursor / Codex users: what's missing for your workflow? Budgets per project? Team aggregation? Anomaly alerts? Tell me in the comments.

How I Built a Free Amazon Listing Compliance Checker (75-Char Rule & Scoring)

justin li — Wed, 05 Aug 2026 21:53:08 +0000

How I Built a Free Amazon Listing Compliance Checker

Amazon rejects or suppresses listings for reasons most sellers don't see coming: titles a few characters too long, ALL-CAPS words, promotional phrases, keyword stuffing. The rules are scattered across style guides, and sellers find out the hard way — after the listing is already live.

So I built a free listing compliance checker that runs a deterministic scoring pass over any listing and tells the seller exactly what would fail, before they publish.

What It Checks

The checker evaluates a listing across the rules that actually matter:

Check	Rule	Why
Title length	≤ 75 characters	Amazon's new title limit (2026) — the top rejection reason
Title minimum	≥ 30 characters	Too short = wasted keyword space, lower ranking
Keyword density	≤ 25% top-word	Stuffing triggers suppression
ALL-CAPS abuse	< 85% uppercase ratio	Format abuse flag
Bullets	5 recommended, ≤ 20 words each	Structure + mobile readability
Description	≥ 120 characters	Thin content
CTA	buy now / shop now / etc.	Conversion basics
Hype words	no best/perfect/guaranteed/#1	Compliance + ad policy risk

The Scoring Logic

Every rule maps to a deduction, so the score isn't a mystery number — each point loss is explained:

function scoreListing({ title, bullets, description }) {
  let score = 100;
  const warnings = [];
  if (title.length > 75) { score -= 30; warnings.push('Title over 75 chars'); }
  else if (title.length < 30) { score -= 10; warnings.push('Title too short to rank'); }

  const density = topKeywordDensity(title);
  if (density > 0.25) { score -= 15; warnings.push('Keyword stuffing risk'); }

  if (uppercaseRatio(title) > 0.85) { score -= 10; warnings.push('ALL-CAPS abuse'); }
  if (bullets.length < 5) { score -= 10; warnings.push('Need 5 bullets'); }
  if (bullets.some(b => b.split(/\s+/).length > 22)) { score -= 5; warnings.push('Bullet too long'); }
  if (description.length < 120) { score -= 5; warnings.push('Description too thin'); }
  if (!/\b(buy now|order now|shop now|add to cart)\b/i.test(description)) { score -= 5; warnings.push('Missing CTA'); }
  if (/\b(best|perfect|guaranteed|#1|top-rated)\b/i.test(description)) { score -= 5; warnings.push('Hype word detected'); }

  return { score: Math.max(0, score), warnings };
}

The UI color-codes the result — green ≥ 80, amber ≥ 60, red below — and lists every warning in plain language.

Why a Checker (Not Just a Generator)

We already built an AI listing generator. But sellers have existing listings they've written by hand, and they need to know why one underperforms. A deterministic checker is:

Trustworthy — no AI hallucination, every rule is explicit
Educational — sellers learn the rules by seeing them applied to their own text
Instant — no API key, no login, paste and check

It also feeds back into our generator: the same scoring function runs on every AI output, so generated listings ship with a compliance score attached.

What I Learned

The 75-char rule is the #1 pain point — most rejected titles are simply too long, and sellers don't realize spaces count.
Specific warnings beat a score — "Score: 45" is useless; "Title is 82 chars (over 75)" is actionable.
Deterministic tools build trust — for compliance, sellers trust a fixed rule engine more than "AI vibes".
Free tools are the top of the funnel — the checker is free and open; it's what gets sellers in the door before they ever touch the paid generator.

Try It

Free, no signup:

👉 Amazon Listing Checker

And if you need a new listing generated with compliance baked in:

👉 ListingAI — AI Listing Generator

Part of the SellerTools platform — AI tools for Amazon & TikTok Shop sellers.

How I Built an AI Amazon Listing Generator with Compliance Scoring in 30 Seconds

justin li — Wed, 05 Aug 2026 20:59:11 +0000

How I Built an AI Amazon Listing Generator with Compliance Scoring in 30 Seconds

Writing product listings for Amazon is deceptively hard. You're not just writing copy — you're navigating a maze of policy rules: title length limits, banned promotional words, character constraints per bullet, and marketplace-specific quirks.

I spent weeks watching sellers (including myself) burn hours on listings that got rejected or underperformed. So I built an AI listing generator that bakes compliance checks into the generation itself, not as an afterthought.

Here's how it works under the hood.

The Core Problem

A "good" Amazon listing isn't just persuasive. It has to be:

Compliant — titles ≤ 75 characters (the new Amazon rule), no promotional phrases ("best", "cheap", "100% quality"), no ALL-CAPS abuse
Structured — title + 5 bullet points + description
Scored — so the seller knows quality before publishing

Generic AI writers handle #1's creativity but ignore #2 and #3 entirely. That's the gap.

Architecture: Compliance-First Prompting

Instead of generating free-form text and validating later, I inject the rules into the prompt and then run a deterministic scoring pass on the output. (The prompt below is simplified — the real one is parameterized per product.)

[SYSTEM]
You are an Amazon listing expert. Rules:
- Title MUST be ≤ 75 characters
- No promotional words: best, cheapest, premium (unless brand)
- No ALL-CAPS words
- Exactly 5 bullet points, each ≤ 20 words
- Include: product name, key feature, material, use case, benefit

[USER]
Product: Portable Blender
Category: Kitchen & Dining
Features: 300ml, USB-C rechargeable, 6 blades, travel-friendly
Target market: US

The model returns a structured listing. Then a scoring function evaluates it:

function scoreListing(listing) {
  let score = 100;
  const title = listing.title || '';
  if (title.length > 75) score -= 30;                    // hard compliance
  if (title.length < 30) score -= 10;                    // too short to rank
  if (keywordDensity(title) > 0.25) score -= 15;         // stuffing risk
  if (uppercaseRatio(title) > 0.85) score -= 10;         // ALL-CAPS abuse
  if (listing.bullets.length < 5) score -= 10;
  if (listing.bullets.some(b => b.split(/\s+/).length > 22)) score -= 5;
  if (listing.description.length < 120) score -= 5;
  if (!/\b(buy now|order now|shop now|add to cart)\b/i.test(listing.description)) score -= 5;
  if (/\b(best|perfect|guaranteed|#1|top-rated)\b/i.test(listing.description)) score -= 5;
  return Math.max(0, score);
}

The score isn't decorative. Every deduction maps to a specific warning, and the UI color-codes the result — green at 80+, amber at 60+, red below. Sellers see exactly which rule their listing would break before hitting publish, and can regenerate with a tighter prompt. There's also a free Listing Checker for validating listings you've already written.

The 30-Second UX

The user flow is deliberately boring-fast:

Paste product name + features
Click generate
Get a scored listing with a compliance badge

No account required for the first 5 generations. That frictionless start is what turned a dev tool into something sellers actually use daily.

What I Learned

Compliance rules change per marketplace — TikTok Shop's rules differ from Amazon's. Keep them in a config, not hardcoded.
Scoring drives trust — a number ("Score: 95") makes sellers feel the AI is accountable. Vague output doesn't.
Compliance-first prompting beats post-hoc validation — when the rules are in the prompt, most outputs pass on the first pass; the deterministic scorer catches the stragglers and tells the seller exactly why.
Free tier is the growth engine — the free tools (listing checker, keyword research) are what bring sellers in; the Pro generator is what keeps them.

Try It

The tool is live and free to try — no signup:

👉 ListingAI — AI Listing Generator

There's also a free Listing Checker if you just want to check your existing listings against compliance rules.

Part of the SellerTools platform — AI tools for Amazon & TikTok Shop sellers.