Cost & Pricing
Three tools, three completely different cost structures: token-based pay-as-you-go, a free tier that covers most small teams, and a flat monthly subscription. Understanding which model fits your team size and usage pattern determines whether AI tooling costs you $0, $15, or $400 per month.
Three Fundamentally Different Pricing Models
BEFORE: You paid a flat monthly electricity bill regardless of usage. In a cold month, you heated your home constantly; in summer, you used almost nothing — but the bill was the same. Predictable, but potentially wasteful.
PAIN: That model fails when usage is highly variable. A team that spikes in December (end-of-year release) and idles in August pays the same flat rate all year. Pay-per-use pricing rewards the teams that use tools efficiently — but adds the cognitive overhead of watching a meter.
MAPPING: Claude Code (token-based) is a pay-per-sip water fountain — you pay exactly for what you drink. Gemini CLI (free tier + pay-per-token for paid) is a public water fountain — free up to the pressure limit, then metered beyond. GitHub Copilot (flat subscription) is a water subscription box — fixed monthly delivery regardless of how much you drink. Which model wins depends on how predictably you drink.
Solo Developer: Typical Monthly Cost
Baseline assumptions: 5 PRs/day, 50 IDE code completions/day, 10 AI code reviews/week, occasional architecture discussions. This is a moderately active solo developer, not a power user.
| Usage pattern | Claude Code | Gemini CLI | Copilot |
|---|---|---|---|
| 5 PR reviews/day × 22 work days | ~$3.00/mo (sonnet, w/ caching) | $0 (free tier: 110 req/day) | Included in subscription |
| 50 completions/day | Completions not Claude's model; use IDE | Not Gemini's primary use | Core feature — unlimited |
| 10 code reviews/week (deep) | ~$1.50/mo (deep context, sonnet) | $0 (within free tier) | Not supported via CLI |
| Occasional architecture sessions (1hr/week) | ~$4.00/mo (long context conversations) | ~$0 free / $0.20 paid | Via IDE chat (included) |
| Monthly total | ~$8–12/mo | $0–2/mo | $10/mo (fixed) |
For a solo developer, Gemini CLI is free for core usage patterns. Claude Code at ~$8–12/mo is competitive with Copilot's $10/mo, but provides more powerful autonomous coding capability. The comparison changes significantly when you factor in Copilot's IDE completion feature — if you want AI completions as you type, Copilot is still the market leader there, and the other two don't directly compete on that surface.
Team of 5: Where Usage Multiplies
A 5-person startup team doing active development: each developer opens ~5 PRs/week, runs ~3 architecture discussions/week, and uses AI review on all PRs. CI automation runs on every PR across all developers.
The Gemini CLI free tier holds at this team size — 5 developers doing 20 PRs/month each generates only 100 API requests, against a 1,500/day free limit. CI automation may push over the free tier for busy teams, but the paid Flash model at ~$0.0001/request barely registers. Claude Code at ~$28–35/mo provides substantially more autonomous capability than Copilot CLI at $95/mo — the capability-per-dollar comparison favors the API-based tools strongly.
Team of 20: Enterprise Pricing Kicks In
At 20 developers, procurement, compliance, and audit controls start mattering as much as cost. Enterprise tier features (SSO, audit logs, policy controls, SLA guarantees) change the comparison.
| Dimension | Claude Code (Anthropic Teams) | Gemini (Vertex AI) | Copilot Business/Enterprise |
|---|---|---|---|
| Pricing tier | Anthropic Teams: $30/user/mo + API usage | Google Cloud Vertex AI: pay-per-token (same model, enterprise SLA) | Copilot Business: $19/user/mo; Enterprise: custom |
| Monthly fixed cost (20 users) | $600/mo + API usage (~$200–400) | $0 fixed; ~$50–150/mo API | $380/mo (Business) or custom (Enterprise) |
| Total estimated/mo | $800–1,000/mo | $50–150/mo | $380/mo+ (fixed) |
| Audit logs | Yes — Teams tier | Yes — Cloud logging | Yes — Business tier |
| SSO / SAML | Yes — Teams tier | Yes — Google Workspace | Yes — Business tier |
| Data residency | US and EU available | Full GCP region control | US and EU available |
| SLA | 99.9% uptime SLA | GCP SLA (99.95%) | GitHub SLA (99.9%) |
For teams of 20+, the Anthropic Teams plan ($30/user/mo) plus API usage can exceed $1,000/mo — significantly more than Copilot Business at $380/mo. However, the comparison is not apples-to-apples: Claude Code provides autonomous code writing and review that Copilot CLI does not. Teams that compare on raw cost without accounting for what each tool actually does will reach misleading conclusions. Calculate the time saved per developer, not just the license cost.
Cost Optimization Strategies
Each tool has specific levers for reducing cost without sacrificing quality:
# WHAT: Use Haiku for simple tasks (linting, formatting, small rewrites)
# WHY: Haiku costs 10x less than Sonnet for equivalent short tasks
# GOTCHA: Haiku lacks Sonnet's reasoning for complex refactors — know the boundary
claude --model claude-haiku-3-5 -p "Fix all ESLint errors in this file"
# WHAT: Enable prompt caching for static system context
# WHY: Repeated CI calls with the same system prompt save ~90% on cached tokens
# Set ANTHROPIC_ENABLE_CACHING=1 or use the API cache_control parameter
# WHAT: Scope context carefully — don't dump the whole repo
# WHY: More files = more input tokens = higher cost
# Instead of: claude "review the codebase"
claude -p "review $(git diff HEAD~1 --name-only | head -5 | tr '\n' ' ')"
# WHAT: Use --output-format stream-json for long tasks to detect early failures
# WHY: Cancel a bad run early instead of paying for the full output
claude -p "refactor the entire payment module" --output-format stream-json# WHAT: Use Flash model in CI and for bulk tasks
# WHY: Gemini Flash is 16x cheaper than Pro and handles most code tasks well
# GOTCHA: Flash has a smaller context window — chunk large files
gemini -p "summarize this file" --model gemini-2.0-flash --no-interactive
# WHAT: Reserve free tier for high-value interactive work
# WHY: Free tier is personal — use it for architecture and design, not CI spam
# In CI: use paid Flash; in interactive: use free tier or paid Pro
# WHAT: Monitor daily request count to avoid hitting free tier ceiling
gemini config get usage
# Output: { "requests_today": 47, "daily_limit": 1500 }
# WHAT: Use --output-format json and parse only the needed fields
# WHY: Shorter prompts that ask for less verbose output use fewer output tokens
gemini -p "List only the file names with bugs, no explanation" \
--model gemini-2.0-flash --no-interactive --output-format json# WHAT: Copilot CLI is fixed cost — maximize IDE completion usage
# WHY: The per-user fee covers unlimited completions; use them heavily
# In VS Code: Copilot autocomplete is always on — type code, let Copilot complete
# WHAT: Use gh copilot for quick shell command lookups (its actual strength)
# GOTCHA: Don't try to use it for tasks better suited to Claude Code or Gemini
gh copilot suggest -t shell "delete all Docker images older than 7 days"
gh copilot explain "git rebase -i HEAD~5"
# WHAT: Delegate automation to Claude Code; use Copilot only for completions
# WHY: $19/user/mo for completions + $8–12/mo for Claude Code (API)
# = hybrid stack costing ~$27–31/mo total, doing everything well
# WHAT: If on Business tier, ensure all seats are active users
# WHY: Unused seats at $19/mo waste budget — audit quarterly
gh api /orgs/YOUR_ORG/copilot/billing --jq '.seat_breakdown'ROI Framework
Every CFO will ask: "what are we getting for this?" Here is the math that makes AI tooling defensible in any budget conversation.
The break-even analysis is compelling for all three tools: at a $100/hr developer rate, saving even 15 minutes per day (1.25 hours/week) generates $500/month in value — an order of magnitude above the cost of any of these tools. The ROI argument is not whether AI tooling pays off (it does), but which tool maximizes time saved per dollar spent for your specific team's workflow.
Beyond time saved, consider bugs prevented. A single production incident from a security bug caught by automated review (average cost: $15,000–50,000 including incident response, customer impact, and engineer time) would pay for years of Claude Code or Gemini CLI usage. Framing AI tooling as "quality insurance" often wins budget conversations that hourly-rate math struggles with.
Full Pricing Table (2026)
| Plan / Model | Claude Code (Anthropic) | Gemini CLI (Google) | GitHub Copilot |
|---|---|---|---|
| Free tier | None — API key required | 60 req/min, 1,500/day (Gemini Flash) | Free for verified open-source maintainers |
| Individual paid | API only: Sonnet ~$3/M in, ~$15/M out | Flash: ~$0.075/M in; Pro: ~$1.25/M in | $10/user/mo (unlimited completions) |
| Small team | API usage — no per-seat fee at this tier | API usage — no per-seat fee | $10/user/mo (no team features) |
| Business/Teams | Anthropic Teams: $30/user/mo + API usage | Google AI Studio: pay-per-token (no seat fee) | Copilot Business: $19/user/mo (audit logs, policy) |
| Enterprise | Anthropic Enterprise: custom pricing + SLA | Vertex AI Gemini: GCP contract pricing | Copilot Enterprise: custom + advanced features |
| Context window pricing | 200K tokens — long context costs more | 1M tokens (Flash); 2M (Pro) — charged per token | N/A — context managed internally |
| Prompt caching | Yes — 90% discount on cached tokens | Google Cache API (Vertex, not CLI) | N/A — flat fee, caching irrelevant |
| Data retention / privacy | Zero data retention on API (Business+) | Google Privacy Policy; Workspace DPA available | GitHub data processing terms |
You now understand the full TCO for all three tools across team sizes:
- Solo devs: Gemini CLI is free; Claude Code ~$8–12/mo; Copilot $10/mo (plus IDE value).
- 5-person team: Gemini CLI $0–8/mo; Claude Code ~$28–35/mo; Copilot Business $95/mo.
- 20-person team: Gemini/Vertex $50–150/mo; Copilot Business $380/mo; Claude Code Teams $800–1,000/mo.
- Hidden costs: large context windows, retry waste, and long debugging sessions hit token-based tools hardest.
- ROI: all three tools pay back their cost at even 15 min/day of developer time saved.
Knowledge Check
Five questions on pricing models, TCO, and cost optimization.
claude-haiku-3-5 instead of claude-sonnet-4-6 for simple CI tasks (fixing lint errors, formatting, small refactors) a significant cost optimization?