cost

AI Build Cost Tracker

Know exactly what each feature costs to build with AI. Budget smarter, spend less.

Process

Phase 1: Show Current State

node ${CLAUDE_PLUGIN_ROOT}/tools/cost-tracker.mjs <project-directory> show

Parse the JSON output for cost history and summary.

Phase 2: Cost Dashboard

Present spending overview:

Total Spend:

• All-time total cost
• This week / this month breakdown
• Average cost per task

By Task/Feature:

• Ranked list of features by cost (most expensive first)
• Flag any outliers (tasks costing 3x+ the average)

By Model:

• Cost breakdown by AI model used
• Potential savings from model switching

Daily Trend:

• Last 30 days of daily spending
• Identify high-spend days

Phase 3: Cost Insights

Generate actionable insights:

1. Where money goes — what types of tasks cost the most (debugging? features? refactoring?)
2. Optimization opportunities — tasks that could use a cheaper model
3. Budget projection — at current rate, monthly spend estimate
4. Cost per line of code — rough estimate based on git diff

Phase 4: Logging New Costs

To log a new cost entry:

node ${CLAUDE_PLUGIN_ROOT}/tools/cost-tracker.mjs <project-directory> log "<label>" <input_tokens> <output_tokens> --model=claude-opus-4-6

Labels should be descriptive kebab-case: auth-feature, bug-fix-login, refactor-api, seo-optimization

Phase 5: Recommendations

Based on spending patterns:

If debugging > 30% of spend:

• "Consider investing in more tests upfront — debugging is your biggest cost driver"
• Suggest running /test-driven-development skill

If a single task > 3x average:

• "The [task] cost $X — consider breaking large tasks into smaller chunks"

Model optimization:

• "Routine refactoring with Sonnet instead of Opus would save ~$X/month"
• "Code review tasks can use Haiku — potential savings of ~$X/month"

Logging Guide

Help the user understand when and how to log costs:

• Log at the END of each task/feature (not during)
• Use consistent labels across sessions
• Include ALL tokens (input + output) from the conversation
• Estimate if exact numbers aren't available (Claude Code shows token usage in the UI)

Phase 6: Build vs. Buy Framework

When reviewing cost data, help the user think about the economics of building with AI:

Worth building with AI (high ROI):

• Features that would take 2+ days manually but 2 hours with AI
• Boilerplate-heavy work (CRUD, migrations, test suites, API endpoints)
• Exploration and prototyping (try 3 approaches, keep the best one)

Consider alternatives:

• If a feature costs >$100 in AI tokens, check if a library or SaaS already does it
• If debugging the same issue costs >$20 in AI tokens, the root cause is architectural — fix the architecture, not the symptom
• If AI-generated code needs significant manual correction, the prompt needs work, not more tokens

Cost benchmarks for solo founders: | Task Type | Expected Cost | If Higher, Investigate | |---|---|---| | New API endpoint | $1-5 | Complex business logic or unclear spec | | Bug fix | $0.50-3 | Missing tests or hard-to-reproduce issue | | Full feature (frontend + backend) | $5-20 | Large scope or frequent rework | | Refactoring | $2-10 | Unclear boundaries or missing tests | | Content/copy generation | $0.25-1 | Too many revision cycles |

Key Principles

• AI is an investment, not a cost. The goal isn't to minimize spend — it's to maximize ROI. A $50 feature that generates $5K MRR is a great investment. But a $50 bug fix that should have cost $5 with better tests is waste.
• Track to learn, not to punish. Cost data reveals where your process is inefficient. High debugging costs mean insufficient tests. High rework costs mean unclear specs.
• Optimize the expensive tasks, not the cheap ones. Switching from Opus to Haiku for a $0.10 task saves nothing. Reducing a $50 debugging session by improving test coverage saves real money.