# aicodingpricing — Buying-decision result spec

Task: t_4e3a1534
Site: https://aicodingpricing.com
Primary keyword: AI coding pricing
Spec date: 2026-05-27
Last pricing source check: 2026-05-27 UTC
Owner: moce
Downstream: frontend implementation by 墨界/墨枢; optional copy polish by 墨笔

## 0. Decision

Upgrade the calculator result from “estimated price + plan fit” to a buying-decision system.

The result page must answer, above the fold:
1. What should I buy?
2. What is the cheaper alternative?
3. What is the safer alternative?
4. Why this recommendation?
5. What official source should I verify before paying?

Do not turn this into a long article. The primary deliverable is a structured result module that changes when provider / workflow / team size / hours / mode changes.

## 1. Product goal

Current issue: the calculator can estimate cost, but the result is too thin for the real search task. Users searching “AI coding pricing” are deciding which plan to buy, whether they will hit limits, and whether a cheaper or safer plan exists.

Target behavior: after any valid input combination, the result module renders:
- one quick answer card
- at least three answer-first price cards
- recommendation / cheaper alternative / safer alternative
- official source + last checked + plan range + limit-risk note
- compare and official-source actions
- visible caveat that estimates are not billing quotes

## 2. Supported personas and scenario presets

The result system must explicitly cover these four scenarios.

| Scenario | Default inputs | Primary question | Default output angle |
|---|---|---|---|
| Solo | team_size=1, hours/week <= 10, subscription | “What should I buy without overpaying?” | Recommend the lowest reliable individual paid plan; show free/cheaper fallback. |
| Power user | team_size=1, hours/week > 10 or agent-heavy workflow | “Will I hit limits?” | Recommend higher-usage individual plan; emphasize limit risk and upgrade threshold. |
| Startup team | team_size=2-20, collaborative workflow | “Should we buy individual seats or team plan?” | Recommend team/business plan when admin/privacy/billing matters; show individual seat math. |
| Enterprise | team_size > 20 or security=high or mode=enterprise | “What is safest for compliance?” | Recommend enterprise/contact-sales or security-first vendor; show custom pricing and admin controls. |

Implementation note: if current calculator does not expose `security_level`, infer high security from team_size > 20, workflow includes “team”, or mode=enterprise/API. Add hidden derived field `buyer_context` rather than adding a visible form control in P1.

## 3. Page structure

### 3.1 Result module order

1. Quick Answer Card
2. Answer-first Price Cards grid, minimum 3 cards
3. Decision Stack: Recommendation / Cheaper alternative / Safer alternative
4. Limit-risk and hidden-cost notes
5. Source Freshness Strip
6. Compare next actions
7. Alert CTA

### 3.2 Above-the-fold copy

Quick Answer title:
`Recommended plan: {recommended_plan_label}`

Quick Answer subtitle:
`For {scenario_label}, start with {recommended_tool_plan}. Estimated monthly cost: {estimated_monthly_cost}. Limit risk: {limit_risk}.`

Primary CTA:
`Verify official pricing`

Secondary CTA:
`Compare cheaper options`

Alert CTA:
`Get pricing change alerts`

Non-negotiable caveat:
`This is an estimate, not a billing quote. Prices, usage pools, taxes, regional availability, promotions, and provider limits can change. Verify the official source before buying.`

## 4. Card field spec

### 4.1 QuickAnswerCard

Required fields:

```ts
type QuickAnswerCard = {
  scenario_id: 'solo' | 'power_user' | 'startup_team' | 'enterprise'
  input_summary: string
  recommended_tool: string
  recommended_plan: string
  estimated_monthly_cost: string
  billing_unit: 'per month' | 'per user/month' | 'usage-based' | 'custom'
  recommendation_reason: string
  limit_risk: 'low' | 'medium' | 'high' | 'unknown'
  limit_risk_note: string
  confidence: 'high' | 'medium' | 'low'
  last_checked: string // YYYY-MM-DD
  official_source_url: string
}
```

UI copy pattern:
`For {input_summary}, {recommended_tool} {recommended_plan} is the best starting point because {recommendation_reason}.`

### 4.2 PriceDecisionCard

Minimum: render 3 cards for every result.
Recommended: render 4 cards when enough data exists.

Required fields:

```ts
type PriceDecisionCard = {
  card_role: 'best_fit' | 'cheaper' | 'safer' | 'power_upgrade' | 'team_option'
  label: string
  tool: string
  plan: string
  plan_range: string
  estimated_monthly_cost: string
  billing_unit: string
  best_for: string
  tradeoff: string
  limit_risk: 'low' | 'medium' | 'high' | 'unknown'
  limit_risk_note: string
  official_source_name: string
  official_source_url: string
  last_checked: string
  source_confidence: 'high' | 'medium' | 'low'
  cta_label: string
  cta_url: string
}
```

Card title examples:
- Best fit: `Best fit: Cursor Pro`
- Cheaper: `Cheaper alternative: GitHub Copilot Pro`
- Safer: `Safer alternative: Cursor Teams`
- Power upgrade: `Upgrade if you hit limits: Claude Max 5x`

### 4.3 DecisionStack

Every main input combination must output exactly three decision sections.

```ts
type DecisionStack = {
  recommendation: DecisionBlock
  cheaper_alternative: DecisionBlock
  safer_alternative: DecisionBlock
}

type DecisionBlock = {
  headline: string
  body: string
  why: string[]
  when_to_switch: string
  official_source_url: string
  event_payload: Record<string, string | number | boolean>
}
```

Section copy labels:
- `Recommendation`
- `Cheaper alternative`
- `Safer alternative`

## 5. Official source registry

Use these as source URLs in P1. All were checked on 2026-05-27 UTC via public pages.

| Tool | Official source | Current plan range for UI | Last checked | Confidence | Limit-risk note |
|---|---|---:|---|---|---|
| Claude / Claude Code | https://claude.com/pricing | Free, Pro $20/mo or $200/yr, Max from $100/mo, Team $25/seat/mo monthly or $20/seat/mo annual, Enterprise custom/API | 2026-05-27 | high | Claude Code is included in Pro and above, but usage limits depend on model, prompts, attachments, tools, context, and traffic. API key auth may bill separately at API rates. |
| OpenAI Codex | https://developers.openai.com/codex/pricing | Free $0, Go $8/mo, Plus $20/mo, Pro from $100/mo, Business usage-based or ChatGPT Business $20/user/mo annual / $25 monthly, Enterprise custom | 2026-05-27 | high | Codex usage shares windows/limits; local messages and cloud tasks may share limits. Credits or API usage can change real cost. |
| Cursor | https://www.cursor.com/pricing | Hobby free, Pro $20/mo, Pro+ $60/mo, Ultra $200/mo, Teams $40/user/mo, Enterprise custom | 2026-05-27 | high | Every plan includes a set amount of model usage; on-demand usage can bill in arrears after included amount is consumed. |
| GitHub Copilot | https://github.com/features/copilot/plans | Free $0, Pro $10/user/mo, Pro+ $39/user/mo, Business/Enterprise plans via GitHub pricing | 2026-05-27 | high | Premium requests are used by chat, agent mode, code review, cloud agent, and CLI; billing transition / upgrade availability may affect purchase path. |
| Tabnine | https://www.tabnine.com/pricing | Code Assistant $39/user/mo annual, Agentic Platform $59/user/mo annual, quote/contact sales | 2026-05-27 | medium | Security-first option; usage may depend on own LLM/on-prem or Tabnine-provided LLM access plus handling fee. |
| Windsurf | https://codeium.com/pricing | Source page needs recheck; old /windsurf/pricing path returns 404 | 2026-05-27 | low | Do not show exact Windsurf price in P1 unless /pricing is parsed successfully. Show as “source needs recheck” if included. |

Source rule:
- Show exact price only when `source_confidence` is high or medium.
- If source page is 404, blocked, or not parsed, do not invent price. Render `source needs recheck` and lower confidence.

## 6. Recommendation matrix

### 6.1 Solo

Trigger:
- team_size = 1
- hours_per_week <= 10
- workflow in basic / mixed / IDE assistant
- mode = subscription

Default decision:
- Recommendation: Cursor Pro or Claude Pro depending selected provider.
- Cheaper alternative: GitHub Copilot Pro if user mainly wants IDE assistance and GitHub/VS Code workflow.
- Safer alternative: Cursor Teams only if privacy/admin concern is present; otherwise Claude Pro with lower usage expectations.

Example output copy:

Recommendation:
`Start with Cursor Pro at $20/mo if you want an AI-first IDE and regular agent usage. It is the simplest paid starting point before jumping to Pro+ or Ultra.`

Cheaper alternative:
`GitHub Copilot Pro at $10/user/mo is cheaper if your workflow stays inside GitHub, VS Code, and code completion/chat. It may be less suitable if you want a full AI-first IDE experience.`

Safer alternative:
`If code privacy, admin control, or team billing already matters, skip individual plans and compare Cursor Teams or GitHub business plans before buying personal seats.`

### 6.2 Power user

Trigger:
- team_size = 1
- hours_per_week > 10 OR workflow=agent-heavy OR sessions/week high

Default decision:
- Recommendation: Claude Max 5x / Codex Pro / Cursor Pro+ depending selected provider.
- Cheaper alternative: stay on $20 plan and tolerate limit risk.
- Safer alternative: higher tier with larger usage pool, or API/pay-as-you-go if usage is spiky and measurable.

Example output copy:

Recommendation:
`Use a higher-usage plan if coding agents are part of your daily workflow. The price jump is justified only when limits interrupt real work, not just because the plan looks more powerful.`

Cheaper alternative:
`Stay on the $20 tier first if your agent use is still occasional. Track when you hit usage limits before upgrading.`

Safer alternative:
`For heavy but irregular coding sprints, compare subscription limits with API or credits-based usage so you do not overpay for idle months.`

### 6.3 Startup team

Trigger:
- team_size between 2 and 20 OR workflow=team/collaboration

Default decision:
- Recommendation: team/business plan when shared billing, privacy, admin controls, or usage analytics matter.
- Cheaper alternative: individual seats when team is tiny and security/admin needs are low.
- Safer alternative: Business/Team plan with no-training-by-default / SSO / analytics.

Example output copy:

Recommendation:
`For a startup team, compare total seat cost, usage analytics, privacy mode, and admin controls. A team plan is usually safer once more than a few people rely on coding agents daily.`

Cheaper alternative:
`For 2-3 developers, individual Pro seats can be cheaper while the workflow is still experimental. Revisit once shared billing or usage visibility becomes painful.`

Safer alternative:
`Choose a team or business plan when customer code, central billing, SSO, or data controls are part of the buying decision.`

### 6.4 Enterprise

Trigger:
- team_size > 20 OR mode=enterprise OR security inferred high

Default decision:
- Recommendation: enterprise/contact-sales or security-first plan.
- Cheaper alternative: not recommended as primary; show “pilot with limited seats” instead of “cheap plan”.
- Safer alternative: Tabnine / Enterprise / private deployment / no-training controls, depending selected vendor.

Example output copy:

Recommendation:
`For enterprise use, do not optimize only for sticker price. Start from security, audit logs, SSO/SCIM, data retention, billing, and support.`

Cheaper alternative:
`Run a limited paid pilot before enterprise rollout, but do not put sensitive or regulated code into individual plans without reviewing the vendor terms.`

Safer alternative:
`If private deployment, air-gapped environments, or code retention guarantees matter, compare enterprise-grade options such as Tabnine or vendor enterprise plans before choosing a lower-cost individual subscription.`

## 7. Answer-first price cards

Render at least these three card roles for every result.

### Card 1 — Best fit

Purpose: direct answer.

Required visible fields:
- Plan name
- Monthly price / billing unit
- Best for
- Why it fits your inputs
- Limit risk badge
- Official source + last checked

Copy template:
`Best fit for {scenario}: {tool} {plan} — {price}. Choose this if {best_for}. Limit risk: {risk}.`

### Card 2 — Cheaper alternative

Purpose: prevent overpaying.

Required visible fields:
- Cheaper plan/tool
- Price difference vs recommendation
- What you give up
- When it is enough
- Official source + last checked

Copy template:
`Cheaper alternative: {tool} {plan} — {price}. You save {delta}, but give up {tradeoff}. Pick it if {condition}.`

### Card 3 — Safer alternative

Purpose: reduce limit/security/policy risk.

Required visible fields:
- Safer plan/tool
- Why safer: more usage / admin / privacy / no-training / enterprise controls
- Price impact
- When it is worth it
- Official source + last checked

Copy template:
`Safer alternative: {tool} {plan} — {price_or_custom}. Safer because {safety_reason}. Worth it when {condition}.`

### Optional Card 4 — Power upgrade

Show when limit_risk=high or scenario=power_user.

Copy template:
`Upgrade path: {tool} {plan}. Do this only after limits interrupt your normal workflow.`

## 8. Result states

### 8.1 Empty state

When inputs incomplete:
`Choose a provider, workflow, team size, hours per week, and billing mode to get a buying recommendation.`

Event: no recommendation event; only `quick_answer_view` after result exists.

### 8.2 Valid result state

Show all modules.

Minimum fields that must change when inputs change:
- `scenario_id`
- `recommended_tool/plan`
- `estimated_monthly_cost`
- `limit_risk`
- at least one of cheaper or safer alternatives

### 8.3 Unknown source state

If source not checked:
`Pricing source needs recheck before purchase. We can still estimate fit, but do not show this as verified pricing.`

Set `confidence=low` and hide exact price if unverified.

### 8.4 High limit-risk state

Condition: hours/week high, power workflow, team size high, or selected plan has known usage-pool caveat.

Banner copy:
`High limit risk: this plan may be interrupted by usage pools, premium requests, credits, model choice, or team-wide usage. Verify official limits before buying.`

### 8.5 Enterprise/custom state

When custom pricing is involved:
- Do not fabricate price.
- Show `custom` / `contact sales`.
- Show seat-count estimate only as an internal comparison if official per-seat plan exists.

Copy:
`This recommendation depends on contract terms. Use this result to shortlist vendors, not to predict final invoice.`

## 9. Event spec

All events must include:

```ts
type BaseEvent = {
  page_slug: 'home' | string
  result_id: string
  provider: string
  selected_plan?: string
  scenario_id: 'solo' | 'power_user' | 'startup_team' | 'enterprise'
  team_size: number
  hours_per_week: number
  mode: 'subscription' | 'api' | 'enterprise' | string
  recommended_tool?: string
  recommended_plan?: string
  estimated_monthly_cost?: number
  limit_risk?: 'low' | 'medium' | 'high' | 'unknown'
  source_last_checked?: string
}
```

### 9.1 quick_answer

Trigger: Quick Answer Card rendered after valid inputs.

Event name: `quick_answer_shown`

Payload additions:
- `answer_type`: `recommended_plan`
- `card_count`
- `confidence`

### 9.2 recommendation

Trigger: user expands/clicks recommendation block or recommendation is first rendered.

Event names:
- `recommendation_shown`
- `recommendation_click`

Payload additions:
- `recommendation_role`: `best_fit`
- `reason_code`: e.g. `lowest_sufficient_plan`, `usage_pool_needed`, `team_controls_needed`, `security_controls_needed`

### 9.3 compare

Trigger: user clicks compare cheaper / compare safer / opens card comparison.

Event names:
- `compare_cards_shown`
- `compare_card_click`

Payload additions:
- `compare_role`: `cheaper` | `safer` | `power_upgrade`
- `compared_tool`
- `compared_plan`
- `price_delta_monthly`

### 9.4 official

Trigger: user clicks an official source link.

Event name: `official_source_click`

Payload additions:
- `official_source_name`
- `official_source_url`
- `last_checked`
- `source_confidence`

### 9.5 alert

Trigger: pricing alert CTA shown/clicked/submitted.

Event names:
- `pricing_alert_cta_shown`
- `pricing_alert_cta_click`
- `pricing_alert_submit_intent`
- `pricing_alert_submit_success`
- `pricing_alert_submit_error`

Rule: success fires only after persistence succeeds. Do not fire success on button click.

## 10. Example result payloads

### 10.1 Solo, Cursor selected

```json
{
  "scenario_id": "solo",
  "quick_answer": {
    "recommended_tool": "Cursor",
    "recommended_plan": "Pro",
    "estimated_monthly_cost": "$20/mo",
    "limit_risk": "medium",
    "limit_risk_note": "Every Cursor plan includes a set amount of model usage; on-demand usage can bill in arrears after included amount is consumed.",
    "official_source_url": "https://www.cursor.com/pricing",
    "last_checked": "2026-05-27"
  },
  "decision_stack": {
    "recommendation": "Start with Cursor Pro if you want an AI-first IDE and regular solo agent usage.",
    "cheaper_alternative": "GitHub Copilot Pro is cheaper at $10/user/mo if GitHub/VS Code workflow is enough.",
    "safer_alternative": "Cursor Teams is safer if admin controls, privacy mode, and centralized billing already matter."
  }
}
```

### 10.2 Power user, Claude selected

```json
{
  "scenario_id": "power_user",
  "quick_answer": {
    "recommended_tool": "Claude",
    "recommended_plan": "Max 5x or Max 20x",
    "estimated_monthly_cost": "from $100/mo",
    "limit_risk": "medium",
    "limit_risk_note": "Usage depends on model choice, prompt length, attachments, tools, context, and traffic; API key auth may bill separately.",
    "official_source_url": "https://claude.com/pricing",
    "last_checked": "2026-05-27"
  },
  "decision_stack": {
    "recommendation": "Move to Claude Max only when Pro limits interrupt real coding work.",
    "cheaper_alternative": "Claude Pro at $20/mo is cheaper if your usage is regular but not daily-agent-heavy.",
    "safer_alternative": "API/pay-as-you-go can be safer for measurable sprints where you want explicit token-level cost control."
  }
}
```

### 10.3 Startup team, Codex selected

```json
{
  "scenario_id": "startup_team",
  "quick_answer": {
    "recommended_tool": "OpenAI Codex",
    "recommended_plan": "Business ChatGPT & Codex or Business Codex",
    "estimated_monthly_cost": "$20/user/mo annual, $25/user/mo monthly, or usage-based",
    "limit_risk": "medium",
    "limit_risk_note": "Business and Enterprise can extend usage with credits; local and cloud task limits may differ by plan.",
    "official_source_url": "https://developers.openai.com/codex/pricing",
    "last_checked": "2026-05-27"
  },
  "decision_stack": {
    "recommendation": "Use Business when shared workspace, admin controls, MFA/SSO, and no-training defaults matter.",
    "cheaper_alternative": "Individual Plus seats can be cheaper for a small pilot, but admin and shared billing are weaker.",
    "safer_alternative": "Enterprise is safer when audit, domain controls, data retention, or custom terms are required."
  }
}
```

### 10.4 Enterprise, security-first

```json
{
  "scenario_id": "enterprise",
  "quick_answer": {
    "recommended_tool": "Tabnine or vendor Enterprise plan",
    "recommended_plan": "Enterprise / quote",
    "estimated_monthly_cost": "custom or from $39-$59/user/mo annual for Tabnine platform plans",
    "limit_risk": "unknown",
    "limit_risk_note": "Enterprise cost depends on deployment model, LLM access, security requirements, and contract terms.",
    "official_source_url": "https://www.tabnine.com/pricing",
    "last_checked": "2026-05-27"
  },
  "decision_stack": {
    "recommendation": "Start from deployment, compliance, retention, SSO/SCIM, and audit needs before comparing sticker price.",
    "cheaper_alternative": "Run a limited pilot on individual/team seats only with non-sensitive code and written policy approval.",
    "safer_alternative": "Private, VPC, on-prem, or enterprise vendor plans are safer when code retention and governance matter."
  }
}
```

## 11. Frontend implementation notes

1. Keep the calculator above the result; do not move result below long SEO content.
2. Render source/freshness directly inside each card, not only in a table lower on the page.
3. If user changes inputs, update result immediately and fire new result events with a new `result_id`.
4. Preserve existing events `tool_start`, `tool_result`, `calculator_usage`, `provider_recommended`, `recommendation_shown`, `pricing_click`, `pricing_cta_click`; add new P1 events without breaking historical tracking.
5. Do not show provider logos if existing brand safety policy uses plain text names.
6. Keep mobile first: cards stack vertically at 390px, source strip remains readable, CTAs are full-width.
7. Accessibility: each card should have an h3, badges should have text labels, source links should include provider name.

## 12. SEO / content implications

Result module should produce crawlable static default copy for at least one default scenario, but personalized results can be client-rendered.

Recommended default static scenario:
- Scenario: Solo
- Provider: Cursor / Claude / Codex / Copilot comparison
- Copy focus: “which AI coding plan should I buy?”

Add FAQ entries only if implementation scope allows:
1. `What is the cheapest AI coding tool plan?`
2. `Which AI coding plan is safest for a team?`
3. `Why can AI coding tool invoices be higher than the monthly plan price?`
4. `How often are AI coding prices checked?`

## 13. NOT-DO

- Do not build accounts, payment, or saved estimates in P1.
- Do not claim final billing accuracy.
- Do not invent exact enterprise prices.
- Do not include unverified Windsurf exact pricing until the official pricing URL is parsed successfully.
- Do not fire alert submit success before persistence succeeds.
- Do not hide official source/freshness in a lower table only.
- Do not add a full admin backend for pricing sources in this task.

## 14. Acceptance checklist

Product / UX:
- [ ] Calculator result renders a Quick Answer Card.
- [ ] Every valid result renders at least 3 answer-first price cards.
- [ ] Every main input combination renders Recommendation / Cheaper alternative / Safer alternative.
- [ ] Solo, power user, startup team, and enterprise scenarios are covered.
- [ ] Cards show official source, last checked, plan range, confidence, and limit-risk note.
- [ ] High limit-risk state has a visible warning.
- [ ] Unknown/unverified source state does not show fabricated exact price.
- [ ] Mobile 390px has no horizontal overflow.

Data / analytics:
- [ ] `quick_answer_shown` fires on valid result render.
- [ ] `recommendation_shown` and `recommendation_click` include recommendation role and reason code.
- [ ] `compare_cards_shown` and `compare_card_click` include cheaper/safer/power role.
- [ ] `official_source_click` includes source URL, confidence, and last checked.
- [ ] `pricing_alert_submit_success` fires only after successful persistence.
- [ ] Existing tool events remain intact.

Content / trust:
- [ ] Claude, Codex, Cursor, GitHub Copilot source URLs are visible.
- [ ] Source checked date uses 2026-05-27 or newer.
- [ ] Estimate disclaimer is visible near result, not only footer.
- [ ] Enterprise/custom plan text avoids fake exact price.
- [ ] Limit-risk notes mention usage pools, premium requests, credits, on-demand billing, API overage, or model/context effects where relevant.

Downstream handoff:
- [ ] Frontend can implement from this spec without another product decision.
- [ ] 墨析 can verify event names from analytics.
- [ ] 墨笔 can polish microcopy without changing IA or data fields.