Skip to main content
skill CX Codex

pricing-strategist · daffy0208 — Claude Code skill: what it does, how to install

pricing-strategist gives an agent a working framework for SaaS pricing: the value metric, tier structure, feature packaging and price tests.

MIT 180 installs ★ 39 updated 2025-12-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add daffy0208/ai-dev-standards --skill pricing-strategist -a claude-code
Open on GitHub

What pricing-strategist does

The skill hands the agent a step-by-step path. It starts with the value metric you bill on, then picks a model: flat rate, tiers, pay-per-use or a hybrid. After that come three tier levels and the job of sorting features between them.

What sits inside: a comparison table for metrics, a YAML template for a tier sheet, notes on anchor pricing and annual discounts, and a section on A/B testing price points. The tier template comes with example limits on users and projects.

Three tiers, not five: that is the skill's own instruction, and it also says not to put the product's core value behind a paywall. The dollar figures in its examples exist to show anchor logic, so your own numbers still have to come from you.

What it helps with

  • pick a value metric that scales with customer value
  • lay out three tiers with a clear upgrade path
  • spread features across plans without walling off the core
  • work out an annual discount and explain the saving
  • plan an A/B test between two price points

Example prompts for the agent

  • Pick a value metric for our SaaS and draft a three-tier price sheet.
  • Sort these features across Starter, Pro and Business plans.
  • Plan an A/B test between two price points and tell me what to compare.

How to install pricing-strategist

1Skills CLI (Vercel)

npx skills add daffy0208/ai-dev-standards --skill pricing-strategist -a claude-code

2Manually: put the files in place

~/.claude/skills/pricing-strategist/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/pricing-strategist/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about pricing-strategist

How to install pricing-strategist in Claude Code?

Run npx skills add daffy0208/ai-dev-standards --skill pricing-strategist -a claude-code. The skill file lands at ~/.claude/skills/pricing-strategist/SKILL.md.

What does pricing-strategist do?

It walks an agent through pricing work: choosing a value metric, picking a pricing model, building three tiers, gating features, and testing price points.

Which pricing models does the skill cover?

Four: a flat rate, tiered plans, usage-based billing, and a hybrid of a base fee plus per-unit charges. Each comes with its trade-offs.

Source text

SKILL.md · MIT
---
name: pricing-strategist
description: Design and optimize pricing strategies for SaaS products including tiering, packaging, value metrics, and experimentation. Use when setting initial pricing, optimizing conversion, expanding revenue, or when users ask about pricing strategy, monetization, or revenue optimization.
license: Complete terms in LICENSE.txt
---

# Pricing Strategist

Design pricing strategies that maximize revenue while keeping customers happy.

## Core Principles

1. **Pricing is a growth lever**: 1% improvement in pricing = 11% improvement in profit (McKinsey)
2. **Price to value, not cost**: Charge based on value delivered, not what it costs you
3. **Simple > Clever**: 3 tiers beats 5 tiers; clear packaging beats complex
4. **Experiment continuously**: A/B test, iterate, optimize

## Pricing Strategy Framework

### Step 1: Determine Your Value Metric

**Value metric** = What you charge for (users, projects, API calls, etc.)

**Good value metrics**:

- Align with customer value (as they get more value, they pay more)
- Easy to understand and predict
- Grow naturally with usage

**Examples**:

```yaml
Slack: Per active user
  ✅ Grows with team size
  ✅ Easy to understand
  ✅ Aligns with value

Twilio: Per API call
  ✅ Grows with usage
  ✅ Predictable for users
  ✅ Direct value correlation

Dropbox: Storage size
  ✅ Clear metric
  ✅ Grows with needs
  ⚠️ Can be gamed (compression)

AWS: Everything (CPU, storage, bandwidth, etc.)
  ⚠️ Complex but accurate
  ⚠️ Hard to predict costs
  ✅ Pay for what you use
```

**Value Metric Decision Matrix**:

| Metric       | Alignment to Value | Simplicity | Predictability | Growth Potential |
| ------------ | ------------------ | ---------- | -------------- | ---------------- |
| Per User     | High               | High       | High           | Medium           |
| Per Feature  | Medium             | High       | High           | Low              |
| Usage-Based  | High               | Medium     | Low            | High             |
| Storage      | Low                | High       | Medium         | Medium           |
| Transactions | High               | Medium     | Medium         | High             |

### Step 2: Choose Your Pricing Model

**Flat Rate**:

```
$99/month - unlimited everything
```

- ✅ Simple to understand
- ✅ Easy to sell
- ❌ Leaves money on table
- ❌ Doesn't scale with value

**Tiered Pricing**:

```
Starter: $29/mo  - 5 users
Pro:     $99/mo  - 20 users
Business: $299/mo - Unlimited users
```

- ✅ Captures different customer segments
- ✅ Upsell path clear
- ⚠️ Anchor pricing matters

**Usage-Based**:

```
$0.01 per API call
First 10,000 free
```

- ✅ Perfect alignment with value
- ✅ Low barrier to entry
- ❌ Unpredictable for customers
- ❌ Hard to forecast revenue

**Hybrid** (Best of both):

```
Base: $49/mo + $0.50 per extra user
```

- ✅ Predictable base + scales with value
- ✅ Lower barrier than pure per-seat
- ⚠️ More complex to explain

### Step 3: Create Your Pricing Tiers

**The Rule of 3**:

- **Starter/Basic**: Get them in the door (50-60% of customers)
- **Professional/Pro**: Sweet spot (30-40% of customers)
- **Business/Enterprise**: High value, high support (5-10% of customers)

**Tier Design Template**:

```yaml
Tier 1 - Starter ($29/mo):
  Target: Individuals, tiny teams, trying it out
  Value Limit: 5 users, 10 projects
  Features: ✅ Core features
    ✅ Basic support (email)
    ❌ Advanced features
    ❌ Integrations
    ❌ Custom anything

Tier 2 - Professional ($99/mo):
  Target: Small-medium teams, main product
  Value Limit: 20 users, 100 projects
  Features: ✅ Everything in Starter
    ✅ Advanced features
    ✅ Integrations (Slack, etc.)
    ✅ Priority support
    ✅ API access
    ❌ Custom SLA
    ❌ SSO

Tier 3 - Business ($299/mo):
  Target: Larger teams, mission-critical
  Value Limit: Unlimited users, unlimited projects
  Features: ✅ Everything in Professional
    ✅ Advanced security (SSO, SAML)
    ✅ Custom SLA
    ✅ Dedicated support
    ✅ Custom integrations
    ✅ Training & onboarding
```

**Anchor Pricing Strategy**:

```
Starter:  $29/mo  (entry point)
Pro:      $99/mo  (3.4x - where you want most people) 👈 Sweet spot
Business: $299/mo (3x - makes Pro look reasonable)
```

Most customers choose the middle tier when:

- Middle tier is 3-4x the starter price
- Top tier is 2-3x the middle tier

### Step 4: Feature Packaging

**Good Feature Distribution**:

```yaml
Starter Tier (60% features):
  - All core CRUD operations
  - Basic reporting
  - Email support
  - Mobile app
  Goal: Get them using the product successfully

Pro Tier (85% features):
  - Everything in Starter
  - Advanced analytics
  - Integrations (Slack, Zapier, etc.)
  - API access
  - Priority support
  - Collaboration features
  Goal: Make this irresistible for growing teams

Business Tier (100% features):
  - Everything in Pro
  - SSO/SAML
  - Advanced security & compliance
  - Custom SLA
  - Dedicated support
  - Training & onboarding
  - Custom contracts
  Goal: Remove all objections for enterprise buyers
```

**Gating Strategy**:

- **Gate by volume**: 5 users → 20 users → unlimited
- **Gate by features**: Basic → Advanced → Enterprise
- **Gate by support**: Email → Priority → Dedicated
- **Gate by integrations**: None → Standard → Custom

❌ **Don't gate core value**: If your product's main value is X, don't gate X
✅ **Gate advanced/power features**: Analytics, integrations, admin features

## Pricing Psychology

### Charm Pricing

```
$99/mo > $100/mo  (1% cheaper, feels 20% cheaper)
$29/mo > $30/mo
```

### Anchoring

```
❌ Bad:
  Basic:    $50
  Premium:  $75  (only 50% more, but not 50% more value?)

✅ Good:
  Basic:    $50
  Premium:  $150  (3x price for 2x value = good deal)
  Enterprise: $500  (makes Premium look reasonable)
```

### Annual Discounts

```
Monthly:  $99/mo  ($1,188/year)
Annual:   $990/year  (Save $198 = 17% discount)
```

**Why offer annual?**:

- Cash flow upfront
- Higher LTV (less churn)
- 15-20% discount is standard

**When to offer**:

- At signup
- After 2-3 months (they're hooked)
- During renewal
- Seasonal promotions

### Free Trial vs Freemium

**Free Trial**:

```yaml
Type: 14-day free trial, no credit card required
When: Product has clear "aha moment" quickly
Pros:
  - Everyone experiences full product
  - Clear conversion point
  - No freeloaders
Cons:
  - Friction at signup
  - Have to convert them quickly
```

**Freemium**:

```yaml
Type: Forever free tier with limitations
When: High viral coefficient, network effects
Pros:
  - No friction at signup
  - Build large user base
  - Word of mouth
Cons:
  - Many users never pay
  - High infrastructure costs
  - Harder to monetize
```

**Decision Matrix**:

- **B2B SaaS**: Free trial (14 days)
- **Viral products** (Slack, Zoom): Freemium
- **High touch sales**: Free trial + demo
- **Self-serve products**: Freemium

## Pricing Experiments

### A/B Testing Pricing

**What to test**:

1. **Price points**: $99 vs $149
2. **Packaging**: Features in each tier
3. **Billing frequency**: Monthly vs annual
4. **Free trial length**: 7 vs 14 vs 30 days
5. **Anchor pricing**: Add expensive tier to make middle tier look good

**How to test**:

```javascript
// Example: Test pricing pages
const pricingVariants = {
  control: {
    starter: 29,
    pro: 99,
    business: 299
  },
  test: {
    starter: 39,
    pro: 129,
    business: 349
  }
}

// Show different prices to 50% of visitors
const variant = Math.random() < 0.5 ? 'control' : 'test'

// Track which converts better
analytics.track('pricing_page_viewed', {
  variant: variant,
  prices: pricingVariants[variant]
})
```

**Metrics to track**:

- Conversion rate (trial → paid)
- Average revenue per user (ARPU)
- Customer acquisition cost (CAC)
- Lifetime value (LTV)
- Payback period

**Sample size calculator**:

```
Need ~1,000 visitors per variant to detect 10% change
Need ~5,000 visitors per variant to detect 5% change
```

### Grandfather Pricing

When raising prices, grandfather existing customers:

```yaml
Scenario: Raising Pro from $99 → $129

Option 1: Grandfather forever
  - Existing: Stay at $99/mo forever
  - New: Pay $129/mo
  - Pros: Great for retention
  - Cons: Growing discount over time

Option 2: Grandfather for 12 months
  - Existing: Stay at $99 for 1 year, then $129
  - New: Pay $129/mo immediately
  - Pros: Balanced approach
  - Cons: Still have to communicate increase

Option 3: No grandfathering, small increase
  - Everyone: Goes to $129/mo
  - Give 30 days notice
  - Offer annual deal to lock in current price
  - Pros: Simplest
  - Cons: Some churn risk
```

### Price Increases

**When to raise prices**:

- Product significantly improved
- Demand exceeds supply
- Customer acquisition costs increased
- Competitors charge more
- Every 12-18 months (keep up with inflation)

**How to communicate**:

```markdown
Subject: [Product] pricing update - your plan is increasing

Hi [Name],

Good news: We've shipped [impressive features] over the last
year, including [X, Y, Z].

Starting [Date, 30+ days away], we're updating our pricing:

- Pro: $99 → $129/mo (+30%)
- Business: $299 → $349/mo (+17%)

Your current pricing:

- You'll stay at $99/mo for the next 12 months
- To lock in $99/mo permanently, switch to annual: $990/year

Why we're increasing prices:

- [Specific value adds]
- [New features]
- [Better support]

Questions? Reply to this email.

Thanks for being with us,
[Founder Name]
```

## Revenue Expansion

### Upsell Strategies

**When to prompt upgrades**:

```javascript
// Hit limit
if (user.projectCount >= user.plan.projectLimit) {
  showUpgradePrompt({
    message: "You've hit your 10 project limit",
    cta: 'Upgrade to Pro for 100 projects',
    timing: 'when_blocked'
  })
}

// Feature discovery
if (user.clickedAdvancedFeature && !user.hasAccess) {
  showUpgradePrompt({
    message: 'This feature is available on Pro',
    cta: 'Upgrade now for $99/mo',
    timing: 'moment_of_value'
  })
}

// Usage-based trigger
if (user.daysActive > 30 && user.plan === 'starter') {
  showUpgradePrompt({
    message: "You're a power user! Unlock more with Pro",
    cta: 'See Pro features',
    timing: 'established_user'
  })
}
```

**Upgrade Incentives**:

- Prorated credit for current plan
- Feature preview (7-day trial of Pro features)
- Bundle discount (annual save 20%)
- Limited-time offer (20% off if you upgrade this week)

### Add-Ons

```yaml
Base Product: $99/mo

Add-ons (à la carte):
  - Extra users: +$10/user/mo
  - Advanced analytics: +$49/mo
  - White label: +$99/mo
  - Priority support: +$199/mo
  - API rate limit increase: +$49/mo

Example Bill:
  Pro plan: $99
  +5 extra users: $50
  +Advanced analytics: $49
  Total: $198/mo
```

**When to use add-ons**:

- Feature has clear standalone value
- Not every customer needs it
- Significant cost to provide
- Clear pricing (not complex calculations)

## Pricing by Market Segment

### Small Business (SMB)

```yaml
Price Point: $29-99/mo
Sales Motion: Self-serve
Features: Simple, easy to use
Support: Email, docs
Decision Maker: End user or team lead
Sales Cycle: Minutes to days
```

### Mid-Market

```yaml
Price Point: $99-999/mo
Sales Motion: Self-serve + light touch
Features: Integrations, collaboration
Support: Priority email, chat
Decision Maker: Department head
Sales Cycle: Days to weeks
```

### Enterprise

```yaml
Price Point: $1,000+/mo (often $10k-100k+)
Sales Motion: High-touch sales
Features: SSO, custom, security, SLA
Support: Dedicated account manager
Decision Maker: VP, C-level, procurement
Sales Cycle: Weeks to months
```

## Pricing Metrics

### Key Metrics to Track

```typescript
interface PricingMetrics {
  // Revenue metrics
  mrr: number // Monthly Recurring Revenue
  arr: number // Annual Recurring Revenue
  arpu: number // Average Revenue Per User

  // Conversion
  trial_to_paid_rate: number // %
  free_to_paid_rate: number // % (if freemium)

  // Expansion
  expansion_mrr: number // New revenue from existing customers
  contraction_mrr: number // Lost revenue from downgrades
  net_revenue_retention: number // (Expansion - Contraction) / Starting MRR

  // Efficiency
  cac: number // Customer Acquisition Cost
  ltv: number // Lifetime Value
  ltv_cac_ratio: number // Should be > 3x
  payback_period_months: number // Should be < 12 months

  // Distribution
  customers_by_tier: {
    starter: number
    pro: number
    business: number
  }
}
```

### Healthy SaaS Benchmarks

```yaml
Good SaaS Company:
  Trial → Paid: > 15%
  MRR Growth: > 10% month-over-month (early stage)
  Churn Rate: < 5% per month (SMB) or < 1% (enterprise)
  LTV:CAC: > 3:1
  Payback Period: < 12 months
  Net Revenue Retention: > 100% (expansion covers churn)
  Annual Contract Value:
    - SMB: $1k-10k
    - Mid-market: $10k-100k
    - Enterprise: $100k+
```

## Pricing Page Best Practices

### Structure

```
Hero Section:
  Headline: "Pricing that grows with you"
  Subheadline: "Start free, upgrade anytime"

Comparison Table:
  [Starter]  [Pro - Most Popular]  [Business]

  Feature comparison rows

  [CTA Button]  [CTA Button]  [CTA Button]

FAQ Section:
  - Can I change plans?
  - What payment methods do you accept?
  - Do you offer refunds?
  - Can I cancel anytime?

Trust Signals:
  - Testimonials
  - Logos of customers
  - Money-back guarantee
```

### Psychological Tricks

```html
<!-- Highlight most popular tier -->
<div class="pricing-card" data-popular="true">
  <div class="badge">Most Popular</div>
  <h3>Pro</h3>
  <div class="price">
    <span class="amount">$99</span>
    <span class="period">/month</span>
  </div>
  <!-- Larger button, different color -->
  <button class="cta-primary-large">Start Free Trial</button>
</div>

<!-- Show annual savings -->
<div class="billing-toggle">
  <span>Monthly</span>
  <toggle />
  <span>Annual <badge>Save 20%</badge></span>
</div>

<!-- Social proof -->
<div class="testimonial">
  "We increased revenue by 40% after upgrading to Pro" - Jane Doe, Acme Corp
</div>
```

## Quick Start Checklist

### Launching Pricing (MVP)

- [ ] Pick value metric (per-user, usage, etc.)
- [ ] Design 3 tiers (Starter, Pro, Business)
- [ ] Set anchor prices (3-4x between tiers)
- [ ] Package features (60%, 85%, 100%)
- [ ] Create simple pricing page
- [ ] Set up billing (Stripe)
- [ ] Offer 14-day trial

### Optimizing Pricing (Post-Launch)

- [ ] Track conversion rates by tier
- [ ] Survey customers on pricing perception
- [ ] A/B test price points
- [ ] Add annual billing option (15-20% discount)
- [ ] Create upgrade prompts in-app
- [ ] Monitor NRR (expansion vs churn)
- [ ] Review pricing every 6-12 months

## Common Pitfalls

❌ **Pricing too low**: Harder to raise than lower; leaves money on table
❌ **Too many tiers**: 5+ tiers is confusing; stick to 3
❌ **Gating core features**: Don't lock essential value behind highest tier
❌ **Complex value metric**: Users shouldn't need calculator to predict their bill
❌ **Never raising prices**: Customers expect prices to increase over time
❌ **Charging for support**: Support should be included, vary by response time

## Summary

Great pricing strategy:

- ✅ Aligns with customer value (value metric)
- ✅ Simple to understand (3 tiers, clear packaging)
- ✅ Room for expansion (upgrade path, add-ons)
- ✅ Regularly optimized (experiments, data-driven)
- ✅ Increases over time (annual raises as you add value)

© daffy0208 · MIT · daffy0208/ai-dev-standards

Similar skills

All skills for Finance and business →

pricing-strategist by other authors comes first.

pricing-strategist claude-code-skills pricing-strategist compares pricing models, estimates an acceptable price range from survey responses, and sorts features into tiers. Use it when launching a product or reworking its pricing. CX Codex +1 319installs pricing-strategist ognjengt pricing-strategist turns your business context into a tier structure with price points, positioning and upgrade triggers, asking only the questions it still needs. CX Codex +1 1,300installs pricing-strategist ncklrs pricing-strategist structures SaaS pricing tiers, guides value metric choices, and tunes monetization copy using behavioral economics principles. CX Codex +1 221installs pricing-packaging-strategist Alysson Franklin pricing-packaging-strategist — a subagent for B2B SaaS pricing strategy: packaging, usage-based models, enterprise negotiation frameworks, and competitive positioning. CX Codex ★ 1,013repo stars pricing coreyhaines31 Skill guides you through building a pricing strategy: choosing what to charge for, structuring tiers, and setting prices based on customer value perception. Use it when designing prices, moving upmarket, or changing your monetization model. CX Codex +1 92,600installs indie-monetization-strategist curiositech indie-monetization-strategist guides indie developers in choosing monetization models, SaaS pricing tiers, and sponsorship rates. Built for solopreneurs avoiding venture capital. CX Codex +1 403installs pricing-change-strategist OneWave-AI pricing-change-strategist plans a price increase or tier restructure with churn modeling. CX Codex +1 158installs pricing-strategy manojbajaj95 The pricing-strategy skill helps plan SaaS pricing, packaging, and willingness-to-pay research. Use it when setting prices or reconsidering tiers and payment models. CX Codex +1 251installs devtools-pricing-strategy Samuel Berthe devtools-pricing-strategy — a pricing architecture skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode. Guides packaging choices and billing metrics for software developer tools. CX Codex +1 13,900installs

From the same set63

The whole set →
voice-interface-builder voice-interface-builder is a Claude Code skill for adding speech recognition, voice commands, and spoken output to web interfaces. It comes into play when building voice controls or accessibility features. CX Codex +1 187installs Accessibility Engineer The Accessibility Engineer skill guides accessible UI implementation and audits against WCAG 2.1 AA. Use it while building interfaces or reviewing their accessibility. CX Codex +1 181installs forensic-data-engineer forensic-data-engineer turns your agent into a data-forensics pair: audit trails, odd transaction patterns, fraud signals, breach root cause. Handy when you have to explain what changed and who did it. CX Codex +1 181installs data-engineer data-engineer guides agents in designing data pipelines, batch or streaming ETL workflows, and analytics aggregation logic. CX Codex +1 181installs Testing Strategist Testing Strategist — a skill for planning test coverage on the 70/20/10 pyramid, with worked Jest and React Testing Library examples for units, integration and E2E. CX Codex +1 176installs spatial-developer spatial-developer gives your agent working patterns for spatial interfaces: WebXR scenes in the browser, hit-test AR, visionOS views and Three.js interactions. Useful once the project leaves the flat screen. CX Codex +1 175installs Security Architect Security Architect evaluates system designs with STRIDE threat modeling, checks code against OWASP flaws, and validates regulatory standards. CX Codex +1 175installs Focus Session Manager Focus Session Manager is a Claude Code skill that tracks focus sessions, escalates break reminders and intervenes when you code for more than 90 minutes without a break. CX Codex +1 167installs

Project sponsors

Companies that keep this analytics open