pricing
/pricing
Sets price as a decision derived from value, not from cost: chooses the value metric you charge by, triangulates the price against value, cost floor, and the competitive alternative, designs the packaging/tiers, and gates the result on unit-economics sanity (LTV/CAC, CAC payback) and a buy-readiness check. Carries a conditional PLG branch (free-tier and free-to-paid mechanics) invoked only when the motion is product-led. Use when pricing a product for the first time, repricing or repackaging, adding tiers, or when deals stall on price.
- Author
- 0xF4ng ↗
- Repository
- aether-growth-fieldwork ↗
- Licence
- MIT
- Last repository change
- 18.07.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 1
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 18.07.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
- SKILL.md zawiera komentarze HTML (1). Nie widać ich w podglądzie Markdown, a model je czyta.
What it does and when to use it
Sets price as a decision derived from value, not from cost: chooses the value metric you charge by, triangulates the price against value, cost floor, and the competitive alternative, designs the packaging/tiers, and gates the result on unit-economics sanity (LTV/CAC, CAC payback) and a buy-readiness check. Carries a conditional PLG branch (free-tier and free-to-paid mechanics) invoked only when the motion is product-led. Use when pricing a product for the first time, repricing or repackaging, adding tiers, or when deals stall on price.
Original author description
Sets price as a decision derived from value, not from cost: chooses the value metric you charge by, triangulates the price against value, cost floor, and the competitive alternative, designs the packaging/tiers, and gates the result on unit-economics sanity (LTV/CAC, CAC payback) and a buy-readiness check. Carries a conditional PLG branch (free-tier and free-to-paid mechanics) invoked only when the motion is product-led. Use when pricing a product for the first time, repricing or repackaging, adding tiers, or when deals stall on price.
How it works
- Contract
- Before starting
- Inputs
- Decision logic
- Outputs
- Anti-patterns
- Benchmarks
- Validation criteria
- Related skills
- Output format
SKILL.md preview
---
name: pricing
description: >-
Sets price as a decision derived from value, not from cost: chooses the value
metric you charge by, triangulates the price against value, cost floor, and the
competitive alternative, designs the packaging/tiers, and gates the result on
unit-economics sanity (LTV/CAC, CAC payback) and a buy-readiness check. Carries
a conditional PLG branch (free-tier and free-to-paid mechanics) invoked only
when the motion is product-led. Use when pricing a product for the first time,
repricing or repackaging, adding tiers, or when deals stall on price.
triggers:
- /pricing
- user asks how to price or package a product, or what to charge
- pricing, packaging, tiers, value metric, willingness to pay, LTV/CAC
- deals are stalling on price or discounting is out of control
- moving from free to paid, or designing a free tier
role: workflow
version: 1.0.0
sources:
- "David Skok, *SaaS Metrics 2.0* — LTV/CAC and CAC-payback unit economics"
- "Madhavan Ramanujam, *Monetizing Innovation* (2016) — willingness-to-pay first; packaging"
- "Value-based pricing — Patrick Campbell / ProfitWell; van Westendorp PSM"
- "April Dunford, *Obviously Awesome* (2019) — pricing follows positioning"
feeds:
- pmm/gtm-brief
- pmm/launch
related:
- pmm/positioning # price is a function of value, which is a function of positioning
- pmm/icp-research # willingness-to-pay + the value metric come from the ICP
- growth/motion-plg # the PLG branch: free-tier / free-to-paid mechanics
- growth/paid-channel-fit # consumes the LTV/CAC output when scaling paid acquisition
---
<!--
Absorbed, not referenced (Absorption rule):
- LTV/CAC, CAC payback — David Skok, *SaaS Metrics 2.0*
- Willingness-to-pay-first + Leader/Filler/Killer packaging — Ramanujam, *Monetizing Innovation* (2016)
- Value-based pricing + van Westendorp PSM — ProfitWell/Campbell
- "pricing follows positioning" — April Dunford, *Obviously Awesome* (2019)
Transformation: source frameworks rewritten into Fieldwork decision logic — a
readiness gate, value-metric selection, a value/cost/competitor triangulation,
a packaging step with a conditional PLG branch, a unit-economics sanity gate,
and a buy-readiness gate. No external runtime is invoked.
-->
# Pricing
**Role:** Pricing architect. Price is not a number you pick at the end — it is a decision derived from the value the customer gets, floored by your unit economics, and oriented against what they'd otherwise pay. Your job is to choose the right *unit* to charge by, anchor the number to quantified value, package it so the right segment self-selects, and refuse to bless a price that the unit economics or the buyer's readiness can't actually support. You never price cost-plus alone. You never let "we'll figure out pricing later" stand. You never accept a competitor's number as your strategy.
---
## Contract
This skill guarantees:
- Price is **anchored to value first** — the cost floor and the competitor reference are bounds, not the basis.
- A **value metric** (the unit you charge by) is chosen and tested to scale with the value the customer receives.
- **Packaging precedes price points** — tiers are designed around segments and willingness-to-pay before any dollar figure is set.
- The result passes a **unit-economics sanity gate** (LTV/CAC, CAC payback, gross margin) before it is blessed for scale.
- The result passes a **buy-readiness check** (budget authority, trigger, procurement path) before it is taken to market.
- When the motion is **PLG**, the conditional free-tier branch runs (what's free, the upgrade trigger, free-to-paid mechanics); it is skipped otherwise.
- Two output grades: a **DRAFT price hypothesis** is allowed without FINAL positioning (when ICP + named alternative + a value claim are explicit inline); **FINAL pricing** requires FINAL positioning and the gates passed. The skill never self-approves to FINAL.
- The unit-economics gate governs **scaling acquisition**, not whether you may set a v1 price: unknown LTV blocks *paid-scale approval*, not a v1 price for an organic funnel.
---
## Before starting
Confirm (ask or infer):
- **Positioning status** — is positioning FINAL (named alternative + provable value attributes)? Price is a function of value, and value is established by positioning. Pricing ahead of positioning produces a number with nothing to defend it.
- **Value metric candidates** — what does the customer get *more of* as they get more value (seats, usage, outcomes, volume)? The charging unit should scale with that.
- **Willingness-to-pay signal** — any real evidence of what the ICP will pay (sales conversations, lost-deal reasons, current spend on the alternative, survey data). If none, this is a hypothesis to test, not a fact.
- **Motion** — PLG (self-serve, free tier) vs. SLG (sales-led) vs. hybrid. Determines whether the PLG branch runs and how procurement works.
- **Unit-economics inputs** — gross margin, current/target CAC, and retention/expansion data (or that they're unknown — which itself gates scaling).
---
## Inputs
| Input | Required? | Description |
|-------|-----------|-------------|
| Positioning artifact | Required | FINAL positioning; named competitive alternative + value attributes |
| Value metric candidates | Required | The unit(s) that scale with customer value |
| Willingness-to-pay signal | Required | Evidence of what the ICP pays/will pay (or labeled a hypothesis) |
| Motion | Required | PLG / SLG / hybrid (decides the PLG branch) |
| Unit-economics inputs | Optional | Gross margin, CAC, LTV, payback (unknowns gate scaling, not drafting) |
| Brain context | Optional | Pricing history, lost-deal reasons, competitor pricing |
**Brain read (if connected):**
```
brain/read: playbooks/pricing.md (current price + history),
knowledge/competitor-map.md (competitor pricing models),
knowledge/icp-map.md (deciding language + alternatives)
```
**If positioning is not FINAL → allow a DRAFT hypothesis, gate only FINAL:**
```
Founders legitimately need a price hypothesis before positioning is formally reviewed.
Do not hard-block them; gate the grade instead.
IF FINAL positioning exists → proceed to FINAL pricing.
ELSE IF ICP + a named competitive alternative + an explicit value claim are present inline
→ proceed to a DRAFT PRICE HYPOTHESIS. Label the output:
"DRAFT price hypothesis — positioning not yet FINAL. This is a testable starting price,
not a defended one. Finalize positioning (→ /positioning-review) before committing it to
a pricing page, a sales motion, or scaled acquisition."
ELSE (no named alternative or no value claim) → BLOCK. Return:
"Pricing needs at minimum a named competitive alternative and an explicit value claim —
the alternative is your price reference frame and the value claim is your anchor.
Run /icp-research and sketch positioning first, then return here."
```
---
## Decision logic
### Gate 0 — Pricing readiness
```
Criterion 1 — Positioning grade
PASS: FINAL positioning (named alternative + provable value attributes) → FINAL pricing path
BORDERLINE: no FINAL positioning, but ICP + named alternative + value claim present inline
→ DRAFT PRICE HYPOTHESIS path (see Inputs); not a FINAL price
FAIL: no named alternative or no value claim → BLOCK (see Inputs)
Criterion 2 — A value hypothesis exists (what value, to whom, quantifiable)
PASS: the customer's gain/pain-relieved can be stated, ideally quantified
BORDERLINE: value is qualitative only (no number yet) → proceed, flag as hypothesis
FAIL: cannot articulate what value the customer gets → return to positioning
Criterion 3 — Willingness-to-pay signal
PASS: real WTP evidence (deals, current spend on alternative, survey)
BORDERLINE: indirect proxy only (competitor price, gut feel) → label DRAFT-UNVALIDATED
FAIL: no signal and no plan to get any → FLAG: design a WTP test first
IF Criterion 1 = FAIL → BLOCK. Otherwise proceed; carry BORDERLINE labels forward.
```
### Step 1 — Choose the value metric (what you charge by)
The single highest-leverage pricing decision is the *unit*, not the number. A good value metric scales with the value the customer receives, is easy to understand, and is hard to game.
```
Test each candidate metric:
(a) Scales with value: as the customer succeeds more, the bill grows — and they're glad
(b) Predictable to buyer: the customer can estimate their bill without fear of a surprise
(c) Aligned to cost: it correlates loosely with your cost to serve (margin stays sane)
(d) Hard to game: the customer can't get the value while avoiding the metric
Examples (illustrative): seats (collaboration value), usage/volume (consumption value),
outcomes/events (results value), managed assets (scale value).
IF the chosen metric does NOT scale with value (e.g. flat fee while value grows 10×)
→ FLAG: "You will leave money on the table with large accounts and overcharge small
ones. Pick a metric that scales with the value delivered."
```
### Step 2 — Triangulate the price (value / cost / competitor)
Set the number from three reference points, in priority order. Value leads; cost is the floor; competitor is the orientation — never the basis.
```
1. VALUE (the anchor — leads):
Quantify the gain delivered or the pain relieved per period (time saved × loaded
cost, revenue unlocked, risk avoided, headcount deferred). Price captures a FRACTION
of that value. (An *illustrative* starting fraction often discussed for B2B software is
~10–25% — this is a rule of thumb, not a sourced benchmark. Treat it as a sensitivity
range to test against willingness-to-pay, not a number to anchor on.)
2. COST (the floor — never price below sustainable margin):
Price must clear cost-to-serve at a healthy gross margin. Cost sets the floor only;
cost-plus as the BASIS is the anti-pattern (it ignores value entirely).
3. COMPETITOR / ALTERNATIVE (the orientation — not the basis):
Reference the named competitive alternative's price model from positioning. Use it to
understand the buyer's reference frame, not to set your number. Matching a competitor's
price abdicates the value story you just built.
OUTPUT: a price (or price range) with the value math written down — so it is defensible
in a deal, not a guess.
```
### Step 3 — Package into tiers (precedes finalizing price points)
Design packaging around segments and willingness-to-pay, then attach numbers.
```
- Segment the buyers by need + WTP (e.g. individual / team / enterprise).
- Build Good/Better/Best (≤3–4 tiers): each tier targets one segment; the jump between
tiers is a clear, value-aligned reason to upgrade — not a feature grab-bag.
- Classify features (Ramanujam): LEADERS (drive the buy — feature the tier on them),
FILLERS (nice-to-have — don't over-invest), KILLERS (destroy WTP if bundled wrong —
isolate or remove). Never bundle a killer into the entry tier.
**Make it testable:** write one sentence per feature stating why it is a leader / filler /
killer *for this segment*. A classification with no reason is a guess; the sentence is what
makes it reviewable (and catches a "killer" mislabeled as a leader).
- Set the anchor: the high tier frames value and makes the middle tier look reasonable.
GATE — packaging sanity:
PASS: ≤3–4 tiers, each mapped to a segment, with a clear value-based upgrade reason
BORDERLINE: tiers exist but the upgrade trigger is fuzzy → name the trigger
FAIL: 5+ tiers or feature-salad tiers with no segment logic
→ "Too many tiers / no segment logic confuses buyers and depresses
conversion. Collapse to ≤3–4 mapped to real segments."
```
**Conditional PLG branch — run ONLY if motion = PLG (else skip):**
```
- Free tier purpose: pick ONE — acquisition (top-of-funnel reach) OR conversion
(a usage path that naturally hits a paid wall). Don't try to do both with one free tier.
- What's free vs. paid: free must deliver a real "first value moment" yet leave an
obvious reason to upgrade (the upgrade trigger). If free is too generous, no one pays;
too stingy, no one activates.
- Free-to-paid mechanic: the metered limit or capability gate that converts (seats,
usage cap, collaboration, advanced features). Tie it to the value metric from Step 1.
- Conversion diagnostic (not a benchmark): free→paid conversion varies enormously across
freemium / reverse-trial / usage-based / devtools / prosumer motions, so there is no single
"good" number. Instead, compare against *your own activation-qualified cohort over time*: if
conversion is low relative to your activated users, the signal is usually a wrong free/paid
line or a wrong activation definition — not the price.
(Hand off free-tier funnel mechanics in depth to growth/motion-plg.)
- PLG guardrail: do NOT use revenue as the PLG north star. Optimizing price/monetization before
activation and retention are healthy damages the funnel; consult `growth/north-star-metrics`
when a monetization change risks activation, and `growth/motion-plg` for the funnel itself.
```
### Step 4 — Unit-economics sanity gate (absorbed Skok)
Before blessing the price for *scaled* acquisition, the unit economics must hold. This gate is the auxiliary-but-required quantitative check.
```
Criterion A — LTV/CAC
PASS: LTV/CAC ≥ 3 (the value of a customer is ≥ 3× the cost to acquire)
BORDERLINE: 1–3 → viable but margin-thin; tighten CAC or raise LTV before scaling
FAIL: < 1 → you lose money on every customer; do NOT scale acquisition
Criterion B — CAC payback period
PASS: < 12 months (SMB/PLG) or < 18 months (enterprise)
BORDERLINE: 12–18 / 18–24 → financeable only with strong retention/expansion
FAIL: beyond the above → cash-flow trap at scale
Criterion C — Gross margin
PASS: healthy software gross margin (cost-to-serve well under price)
FAIL: margin too thin to fund acquisition or support → reprice or re-architect cost
IF inputs are UNKNOWN → do not bless for scale. Output is DRAFT; recommend instrumenting
LTV, CAC, and payback before any paid-acquisition scale. (Drafting a price is fine;
scaling spend on an unmeasured funnel is not.)
IF any criterion = FAIL → the pricing/packaging or the acquisition cost must change before scale.
```
### Step 5 — Buy-readiness check
A defensible price still fails if the buyer can't actually buy.
```
Criterion — Budget authority: does the ICP buyer control or influence the budget at this price?
Criterion — Trigger / urgency: is there a reason to buy NOW, or is this a "someday" purchase?
Criterion — Procurement path: self-serve checkout (PLG) vs. PO/security review/legal (enterprise)?
→ If the price crosses a procurement threshold (e.g. requires sign-off the buyer lacks),
either fit the price under that threshold or equip the motion for the longer cycle.
PASS: budget + trigger + a clear path to purchase at this price
BORDERLINE: one is weak → name the mitigation (champion to build the case, land-small-expand)
FAIL: price assumes authority/budget the buyer doesn't have
→ "The price is technically defensible but unbuyable by this ICP. Reprice to
the buyer's authority, or change who you sell to."
```
---
## Outputs
| Output | Format | Description |
|--------|--------|-------------|
| Value metric decision | Markdown block | The chosen charging unit + why it scales with value |
| Price triangulation | Block | The number/range with the value math, cost floor, competitor reference |
| Packaging / tiers | Table | Tiers mapped to segments + upgrade triggers (+ free tier if PLG) |
| Unit-economics verdict | Checklist | LTV/CAC, payback, margin — PASS/BORDERLINE/FAIL with the numbers |
| Buy-readiness verdict | Checklist | Authority / trigger / procurement |
**Brain write (if connected):**
```
brain/write: playbooks/pricing.md (price, value metric, packaging, the value math),
decisions/ (why this metric + price — for later repricing)
```
---
## Anti-patterns
| Anti-pattern | Why it fails | Fix |
|---|---|---|
| Cost-plus pricing | Ignores value; systematically underprices high-value products and caps your upside | Anchor to quantified value; use cost only as the floor |
| "We'll figure out pricing later" | Price shapes the product, the motion, and the buyer — deferring it builds the wrong everything | Decide a defensible v1 price now; iterate with data |
| Pricing only against a competitor | A race to the bottom that throws away the value story; assumes their economics are yours | Reference the competitor; set the number from your value |
| A value metric that doesn't scale with value | Flat fee while customer value grows 10× leaves money on the table and overcharges the small | Pick a unit that grows as the customer succeeds |
| Too many tiers / feature-salad packaging | Choice overload depresses conversion; no segment can see "the one for me" | ≤3–4 tiers, each mapped to a real segment with a clear upgrade reason |
| Bundling a "killer" feature into the entry tier | A killer feature destroys WTP for the segment that doesn't want it; drags the whole price down | Isolate killers to higher tiers or remove |
| Scaling acquisition before unit economics hold | LTV/CAC < 1 means every new customer loses money; scale multiplies the loss | Pass the Step 4 gate before any paid-acquisition scale |
| Discounting to close with no floor | Trains buyers to wait for discounts and erodes margin and price integrity | Hold the cost-margin floor; trade discount for term/volume/commitment |
| Pricing before positioning is FINAL | A price with no value story behind it is indefensible in the deal and brittle to reposition | Gate 0: positioning FINAL first |
---
## Benchmarks
Dated and sourced calibration anchors — not guarantees; calibrate to your model.
| Metric | Benchmark | Source |
|--------|-----------|--------|
| LTV/CAC (healthy) | **≥ 3** | David Skok, *SaaS Metrics 2.0* (classic SaaS framework, forEntrepreneurs) |
| CAC payback (SMB/PLG) | **< 12 months** | David Skok, *SaaS Metrics 2.0* |
| CAC payback (enterprise) | **< 18 months** (financeable to ~24 with strong NRR) | Skok ≤12-mo principle extended to enterprise by common practitioner convention |
| Value capture (B2B software) | *Illustrative* ~10–25% of quantified value — a rule of thumb, **not a sourced benchmark** | Fieldwork heuristic; sensitivity-test against WTP |
| Tier count | **≤ 3–4** tiers; more depresses conversion | *Monetizing Innovation* (Ramanujam 2016); ProfitWell |
| Free→paid conversion (PLG) | **No single benchmark** — varies widely by motion; diagnose vs. your own activation-qualified cohort | Fieldwork diagnostic (not a target) |
| Pricing review cadence | Revisit at least **annually** (more often pre-PMF / fast markets) | ProfitWell pricing practice |
---
## Validation criteria
**Output passes if:**
- [ ] Positioning is FINAL before pricing was set (Gate 0)
- [ ] A **value metric** is chosen and shown to scale with customer value
- [ ] The price is **triangulated** (value anchor + cost floor + competitor reference) with the value math written down
- [ ] Packaging is **≤3–4 tiers mapped to segments** with clear upgrade triggers (+ free-tier design if PLG)
- [ ] The **unit-economics gate** (LTV/CAC, payback, margin) is evaluated with real numbers — or scaling is explicitly withheld if unknown
- [ ] The **buy-readiness check** (authority/trigger/procurement) passes or carries a named mitigation
- [ ] Sources declared; Tier-1 frameworks cited; output carries `Confidence` + `Review Trace`
**Output fails if:**
- [ ] Price is set cost-plus or competitor-matched with no value anchor
- [ ] The value metric is flat/decoupled from value delivered
- [ ] 5+ tiers or feature-salad packaging with no segment logic
- [ ] Scaling acquisition is recommended with LTV/CAC < 1 or unknown unit economics
- [ ] The price assumes budget authority the ICP buyer does not have
---
## Related skills
| Skill | When to use |
|---|---|
| `pmm/positioning/SKILL.md` | Before: pricing requires FINAL positioning (value + named alternative) |
| `pmm/icp-research/SKILL.md` | Before: willingness-to-pay + the value metric come from the ICP |
| `growth/motion-plg/SKILL.md` | The PLG branch: free-tier funnel + free-to-paid mechanics in depth |
| `growth/paid-channel-fit/SKILL.md` | After: consumes the LTV/CAC output when deciding to scale paid acquisition |
| `pmm/ai-product-gtm/ai-usage-pricing-growth/SKILL.md` | Instead/alongside for **AI-specific** monetization: token/credit economies, usage-based metering, AI freemium |
| `growth/north-star-metrics/SKILL.md` | Guardrail: ensure a monetization change doesn't damage PLG activation/retention |
| `pmm/gtm-brief/SKILL.md` | Downstream: pricing + packaging feed the GTM brief |
---
## Output format
```
## Pricing Artifact
**Product:** [name] **Motion:** [PLG / SLG / hybrid] **Status:** [DRAFT / FINAL]
### Value metric
Charge by: [unit] — scales with [the value it tracks]
### Price triangulation
Value anchor: [quantified value] → capture ~[%] → [price/range]
Cost floor: [margin check] Competitor reference: [alternative's model]
### Packaging
| Tier | Segment | Key value (leader features) | Upgrade trigger | Price |
|---|---|---|---|---|
| [Good] | … | … | … | … |
| [Better] | … | … | … | … |
| [Best] | … | … | … | … |
[Free tier (PLG only): what's free · upgrade trigger · free→paid mechanic]
### Unit-economics gate
[ ] LTV/CAC: [value] ([PASS/BORDERLINE/FAIL])
[ ] CAC payback: [months] ([PASS/BORDERLINE/FAIL])
[ ] Gross margin: [PASS/FAIL]
### Buy-readiness
[ ] Authority [ ] Trigger [ ] Procurement path → [verdict / mitigation]
```
---
## References & Sources
**Tier 1:**
- David Skok, *SaaS Metrics 2.0* (a long-standing SaaS framework, forEntrepreneurs) — LTV/CAC ≥ 3 and CAC-payback thresholds; the unit-economics sanity gate (Step 4).
- Madhavan Ramanujam, *Monetizing Innovation* (2016) — willingness-to-pay before building; Leader/Filler/Killer feature classification; tier design (Step 3).
- Value-based pricing practice — Patrick Campbell / ProfitWell; van Westendorp Price Sensitivity Meter — value anchoring and WTP testing (Steps 2–3).
- April Dunford, *Obviously Awesome* (2019) — pricing follows positioning; the competitive alternative is also the price reference frame (Gate 0, Step 2).
**Note on the soft ranges:** the value-capture % and free→paid figures are **Fieldwork
heuristics / diagnostics, not sourced benchmarks** (labeled as such above). They are starting
points to test against your own data, not numbers to anchor on.
**Scope boundary (related skills):** this skill is **general value-based pricing**. For
AI-specific monetization — token/credit economies, usage-based metering, freemium calibration
for AI products — use `pmm/ai-product-gtm/ai-usage-pricing-growth` instead (or alongside, for
the AI-usage layer). For the decision to *scale a paid channel* on these unit economics, hand
off to `growth/paid-channel-fit`.
---
*Output metadata (append to every FINAL output):*
```
---
Skill: pricing v1.0.0
Role: workflow
Confidence: [0-100]
Review Trace: [reviews passed, or "DRAFT — pending: positioning FINAL / unit-economics instrumentation"]
Bridge Signals: [bridges consulted, or "none"]
Brain Context: [connected / not connected]
Sources: SaaS Metrics 2.0 (Skok); Monetizing Innovation (Ramanujam 2016); value-based pricing (Campbell/ProfitWell); Obviously Awesome (Dunford 2019)
Generated: [date]
---
```
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · 0xF4ng/aether-growth-fieldwork | 100 | MIT |
| ericrisco/rsc-harness | 100 | MIT |
| lilly-logic-labs/lll-skills | 100 | MIT |
| FrancoStino/opencode-skills-collection | 100 | MIT |
| sickn33/agentic-awesome-skills | 100 | MIT |
| cmj-hub/claude-pricing | 100 | MIT |
| coreyhaines31/marketingskills | 100 | MIT |
| checkout-page/ecommerce-skills | 100 | MIT |
| Jakeschincariol/whale-skill | 100 | MIT |
Database snapshot: 13.11.2026 · package version 9fc1696c3feb (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100pricing-strategy
Set or revise pricing for any product by triangulating value, competition, and cost floor into a recommended structure, price points, and a test plan. Use when someone asks "what should I charge", "how do I price my product", "are we priced too low", "should we go usage-based or… - 100unit-economics
Use when the user wants to calculate or sanity-check unit economics — LTV, CAC, the LTV:CAC ratio, and CAC payback — for a subscription, ecommerce, or services business. Also use when the user mentions lifetime value, customer acquisition cost, payback period, churn,… - 100unit-economics
Run business math: unit economics, pricing, CAC, LTV, margins, break-even. Trigger on "run the numbers", "what's the unit economics", "calculate margins", "pricing model", "break-even", "revenue projection", "cost analysis", "CAC", "LTV", "how much would it cost to", "is this… - 95pricing-strategy
Recommends what to charge from rival pricing pages and price searches, setting value metric, tiers, price points and annual discount. Also designs offers and guarantees, prices by country and plans price increase or sunset notices. Use when asked what to charge, how to tier or how to raise prices. - 100startup-business-models
Use when choosing or evaluating a startup revenue model, pricing/value metric, packaging/tier design, or calculating unit economics (LTV, CAC, payback, gross margin, NRR), including usage-based/credit/AI pricing and variable compute/COGS constraints. - 100plan-pricing
Plan-only pricing audit: value metric, tiers, price points, free-tier boundary, annual and enterprise anchors, and a willingness-to-pay study. Use when "pricing strategy", "what should I charge", or "are we underpriced".