/cost

name: cost
description: "AI Build Cost Tracker — track how much AI is costing you per feature. Use when user wants to track AI spending, understand cost per feature, optimize AI usage, or budget their Claude/GPT costs."
allowed-tools: Bash, Read, Write, Grep

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.