opencode-skills-collection 4.0.53 → 4.0.55

package/bundled-skills/usage-based-pricing/references/detailed-guide.md

@@ -0,0 +1,407 @@
+# Usage-Based Pricing - Detailed Guide
+
+> This file contains the detailed procedure and reference material extracted from `SKILL.md` for focused loading. The root skill defines activation, examples, safety constraints, and limitations.
+
+## Overview
+
+Developers are uniquely sensitive to pricing. They'll calculate unit economics, compare alternatives, and write blog posts about surprise bills. Usage-based pricing works well for developer tools because it aligns cost with value, but it can also create anxiety about unpredictable costs.
+
+The best developer pricing is predictable, transparent, and obviously fair. Developers should be able to estimate their bill before they commit.
+
+
+## Before You Start
+
+Review the `/devmarketing-skills/skills/free-tier-strategy` skill to understand how free tiers connect to paid pricing. Your pricing model should feel like a natural extension of the free tier, not a completely different experience.
+
+
+## Pricing Page Clarity
+
+### Essential Pricing Page Elements
+
+1. **Price per unit, clearly stated**
+```
+$0.01 per 1,000 API calls
+$0.10 per GB stored
+$5 per team member
+```
+
+2. **Usage calculator**
+```
+Estimate your monthly cost:
+API calls per month: [____]
+Storage (GB): [____]
+
+Estimated cost: $XX/month
+```
+
+3. **Tier comparison table**
+```
+                Free        Pro         Enterprise
+API calls       10,000/mo   100,000/mo  Unlimited
+Storage         1GB         50GB        500GB
+Support         Community   Email       Priority
+Price           $0          $29/mo      $299/mo
+```
+
+4. **FAQ answering real questions**
+- "What happens if I exceed my limit?"
+- "How do I monitor my usage?"
+- "Are there any hidden fees?"
+- "Can I set spending limits?"
+
+### Pricing Page Examples
+
+**Excellent: Stripe**
+- Simple percentage per transaction
+- Clear calculator
+- All fees visible
+- Volume discounts transparent
+
+**Excellent: Cloudflare**
+- Free tier generous
+- Paid features clearly differentiated
+- Per-feature pricing available
+- Enterprise custom pricing framed simply
+
+**Poor patterns:**
+- "Contact sales" for any pricing information
+- Prices hidden until signup
+- Complex unit definitions
+- Multiple interdependent metrics
+
+### Price Communication Principles
+
+1. **Lead with simple cases** - Show the "typical" cost first
+2. **Reveal complexity gradually** - Edge cases in FAQ, not main pricing
+3. **Use real numbers** - "$47/month for a typical SaaS app" beats "$0.001 per request"
+4. **Compare to alternatives** - "50% less than AWS" (if true and provable)
+
+
+## Cost Predictability and Caps
+
+### Why Predictability Matters
+
+Developers fear:
+- Unexpected month-end bills
+- Usage spikes from bugs or attacks
+- Being unable to explain costs to managers
+- Services that punish success
+
+### Providing Predictability
+
+**Usage dashboards:**
+```
+Current billing period: March 1-31
+
+API calls:     45,000 / 100,000 (45%)
+Storage:       12GB / 50GB (24%)
+Bandwidth:     89GB / 100GB (89%) ⚠️
+
+Projected bill: $47 (current: $38)
+```
+
+**Usage alerts:**
+```
+Alert settings:
+[ ] 50% of monthly limit
+[x] 75% of monthly limit
+[x] 90% of monthly limit
+[x] 100% of monthly limit
+[ ] Daily usage spike (>2x average)
+```
+
+**Spending caps:**
+```
+Monthly spending cap: $100
+
+When reached:
+( ) Hard stop - service pauses
+(x) Soft stop - alert and require approval
+( ) No stop - continue and alert
+```
+
+### Cap Implementation Considerations
+
+**Hard caps:**
+- Service stops at limit
+- Best for: Development, non-critical
+- Risk: Production outages
+
+**Soft caps:**
+- Service continues, alerts sent
+- Best for: Production, alert required
+- Risk: Unexpected overages
+
+**Burst allowance:**
+- Short-term overage allowed
+- Best for: Handling legitimate spikes
+- Risk: Abuse potential
+
+**Automatic scaling:**
+- Auto-upgrade tier temporarily
+- Best for: Predictable growth
+- Risk: Confusion about costs
+
+
+## Billing Transparency
+
+### The Bill Should Tell a Story
+
+**Bad invoice:**
+```
+Usage charges: $147.00
+Total: $147.00
+```
+
+**Good invoice:**
+```
+API Usage
+- Requests: 245,000 @ $0.01/1,000 = $2.45
+- Bandwidth: 150GB @ $0.10/GB = $15.00
+
+Compute
+- Function invocations: 50,000 @ $0.0001 = $5.00
+- Compute time: 10,000 GB-sec @ $0.0000166 = $0.17
+
+Storage
+- Database: 25GB @ $0.50/GB = $12.50
+
+Platform fee: $29.00 (Pro plan base)
+
+Subtotal: $64.12
+Credits applied: -$10.00 (new user credit)
+
+Total: $54.12
+```
+
+### Usage Visibility
+
+**Dashboard requirements:**
+- Real-time or near-real-time usage
+- Daily/weekly/monthly views
+- Breakdown by resource/project
+- Comparison to previous periods
+- Export for internal analysis
+
+**API for usage data:**
+```bash
+curl https://api.example.com/usage \
+  -H "Authorization: Bearer sk_live_xxx"
+
+{
+  "period": "2024-03-01/2024-03-31",
+  "api_calls": 245000,
+  "bandwidth_gb": 150,
+  "cost_to_date": 54.12,
+  "projected_cost": 62.00
+}
+```
+
+### Billing Cycle Best Practices
+
+- **Monthly billing** - Standard, predictable
+- **Prepaid credits** - Discount for commitment, reduces uncertainty
+- **Annual contracts** - For enterprise, discount for commitment
+- **Billing date choice** - Let customers align with their accounting
+
+
+## Communicating Value vs Cost
+
+### The Value Conversation
+
+Don't just communicate price—communicate value relative to alternatives.
+
+**Alternative cost comparisons:**
+```
+Running this yourself:
+- Server costs: $200/mo
+- Engineer time: $5,000/mo
+- Maintenance: $500/mo
+Total: $5,700/mo
+
+Our service: $99/mo
+You save: $5,601/mo
+```
+
+**Time savings:**
+```
+Without [Product]:
+- 2 weeks to build
+- 4 hours/month to maintain
+
+With [Product]:
+- 30 minutes to integrate
+- Zero maintenance
+
+Developer time saved: 120+ hours/year
+```
+
+### ROI Calculators
+
+For enterprise sales, provide ROI tools:
+
+```
+Your company:
+- Developers: [10]
+- Hours/week on auth: [5]
+- Fully-loaded cost/hour: [$150]
+
+Current cost: $3,000/week = $156,000/year
+
+With [Product]:
+- Integration: 20 hours one-time = $3,000
+- Annual cost: $12,000
+- Maintenance: Near zero
+
+First year savings: $141,000
+```
+
+### Pricing Justification
+
+When prices seem high, justify with:
+1. **Feature completeness** - "Includes what others charge extra for"
+2. **Reliability** - "99.99% uptime saves you from outages"
+3. **Support** - "Engineering support, not offshore scripts"
+4. **Scale** - "Handles 10x traffic without config changes"
+5. **Security** - "SOC 2, GDPR, HIPAA included"
+
+
+## Competitive Pricing Research
+
+### Understanding the Landscape
+
+**Map competitors by:**
+1. Direct competitors (same solution)
+2. Adjacent competitors (different approach, same problem)
+3. Build-it-yourself (internal development cost)
+4. Status quo (doing nothing)
+
+**Pricing model analysis:**
+```
+Competitor A: $0.015/request, no free tier, 99.9% SLA
+Competitor B: $0.008/request, generous free tier, 99.5% SLA
+Open source: $0 + hosting costs (~$0.005/request) + maintenance
+```
+
+### Pricing Position Options
+
+**Premium pricing:**
+- Higher price, higher perceived value
+- Works with: Superior product, enterprise focus
+- Requires: Clear differentiation
+
+**Value pricing:**
+- Comparable price, more features
+- Works with: Feature-rich products
+- Requires: Clear comparison
+
+**Penetration pricing:**
+- Lower price, gain market share
+- Works with: Commoditized features
+- Requires: Path to profitability
+
+**Usage-aligned pricing:**
+- Aligned with customer value
+- Works with: Variable usage patterns
+- Requires: Clear value correlation
+
+### Competitive Analysis Template
+
+For each competitor:
+```
+[Competitor Name]
+Pricing model: [Per-seat / usage-based / flat]
+Free tier: [Yes/No, limits]
+Starting price: [$X/mo or $/unit]
+Enterprise: [Custom / listed price]
+Key differentiator: [Feature/price/market]
+Developer sentiment: [From Twitter, HN, Reddit]
+```
+
+### Price Testing
+
+**A/B testing considerations:**
+- Test different price points (carefully, ethically)
+- Test different packaging (bundles vs. à la carte)
+- Test annual vs. monthly emphasis
+- Test value framing ("save $X" vs. "costs $Y")
+
+**Qualitative research:**
+- Win/loss analysis: Why did they choose us/competitor?
+- Price sensitivity interviews: What would change their decision?
+- Value perception: What do they think is fair?
+
+
+## Pricing Anti-Patterns
+
+### The Surprise Bill
+
+Developers share horror stories:
+- "My $20/month bill became $2,000"
+- "A bug caused infinite loops and I owe $500"
+- No warning, no cap, no mercy
+
+**Solution:** Spending caps, usage alerts, anomaly detection
+
+### The Pricing Maze
+
+- Requires spreadsheet to calculate
+- Different metrics for different features
+- Hidden fees discovered later
+- Changes frequently without notice
+
+**Solution:** Simple, clear, stable pricing
+
+### The Negotiation Game
+
+- "Contact sales" for all meaningful tiers
+- List price is 10x actual price
+- Every customer gets different deal
+- Penalizes customers who don't negotiate
+
+**Solution:** Transparent pricing, volume discounts listed
+
+### The Bait and Switch
+
+- Free tier gets worse over time
+- Prices increase without grandfathering
+- Features move from free to paid
+- "New pricing" disadvantages existing customers
+
+**Solution:** Grandfathering, clear migration paths, community communication
+
+
+## Tools
+
+### Billing Platforms
+
+- **Stripe Billing** - Subscription and usage-based billing
+- **Orb** - Usage-based billing infrastructure
+- **Lago** - Open source billing platform
+- **Metronome** - Usage metering and billing
+- **Chargebee** - Subscription management
+
+### Usage Metering
+
+- **Segment** - Event tracking for usage
+- **Rudderstack** - Open source alternative
+- **Custom** - Most companies build their own metering
+
+### Pricing Pages
+
+- **PricingPage.io** - Templates and inspiration
+- **ProfitWell** - Pricing analytics
+- **Baremetrics** - SaaS metrics and pricing tools
+
+### Competitive Intelligence
+
+- **Competitors.app** - Track competitor pricing changes
+- **Manual monitoring** - Sign up for competitor newsletters
+- **Community research** - Reddit, HN, Twitter sentiment
+
+
+## Related Skills
+
+- `/devmarketing-skills/skills/free-tier-strategy` - Free tier design
+- `/devmarketing-skills/skills/developer-signup-flow` - Getting to the pricing page
+- `/devmarketing-skills/skills/developer-onboarding` - Demonstrating value before price

package/bundled-skills/ux-audit/SKILL.md

@@ -127,6 +127,12 @@ Target: **$ARGUMENTS**
 4. **Minor Issues**: Nice to fix (polish)
 5. **Recommendations**: Specific code changes for each issue
 
+## Example
+
+**User request:**
+
+> Audit screens for UX issues using Nielsen's heuristics and modern mobile UX best practices.
+
 ## Limitations
 
 - Use this skill only when the task clearly matches its upstream source and local project context.

package/bundled-skills/ux-flow/SKILL.md

@@ -66,6 +66,12 @@ Description: $ARGUMENTS
 
 4. Generate the actual page files using `/ss-page` conventions.
 
+## Example
+
+**User request:**
+
+> Design user flows and navigation structure following proven UX patterns.
+
 ## Limitations
 
 - Use this skill only when the task clearly matches its upstream source and local project context.

package/bundled-skills/ux-persuasion-engineer/SKILL.md

@@ -113,6 +113,12 @@ Before finalizing output, the agent asks:
 - [ ] Did I preserve autonomy and accessibility?
 - [ ] Would the flow feel easier, not pushier?
 
+## Example
+
+**User request:**
+
+> Redesign this product flow so layout, sequencing, and cues guide the decision clearly and ethically.
+
 ## Limitations
 - Use this skill only when the task clearly matches the scope described above.
 - Do not treat the output as a substitute for environment-specific validation, testing, or expert review.

package/bundled-skills/variant-analysis/SKILL.md

@@ -3,6 +3,7 @@ name: variant-analysis
 description: Find similar vulnerabilities and bugs across codebases using pattern-based analysis. Use when hunting bug variants, building CodeQL/Semgrep queries, analyzing security vulnerabilities, or performing systematic code audits after finding an initial issue.
 risk: offensive
 source: community
+date_added: "2026-09-04"
 ---
 
 > **⚠️ AUTHORIZED USE ONLY**

package/bundled-skills/varlock/SKILL.md

@@ -3,6 +3,7 @@ name: varlock
 description: "Secure-by-default environment variable management for Claude Code sessions."
 risk: critical
 source: "https://github.com/dmno-dev/varlock"
+date_added: "2026-09-04"
 version: 1.0.0
 ---
 

package/bundled-skills/varlock-claude-skill/SKILL.md

@@ -22,6 +22,12 @@ This skill provides guidance and patterns for secure environment variable manage
 
 For more information, see the [source repository](https://github.com/wrsmith108/varlock-claude-skill).
 
+## Example
+
+**User request:**
+
+> Use @varlock-claude-skill for this task: Secure environment variable management ensuring secrets are never exposed in Claude sessions, terminals, logs, or git commits.
+
 ## Limitations
 - Use this skill only when the task clearly matches the scope described above.
 - Do not treat the output as a substitute for environment-specific validation, testing, or expert review.

package/bundled-skills/vector-database-engineer/SKILL.md

@@ -62,6 +62,12 @@ Expert in vector databases, embedding strategies, and semantic search implementa
 - Cache frequent queries
 - Test recall vs latency tradeoffs
 
+## Example
+
+**User request:**
+
+> Build RAG (Retrieval Augmented Generation) systems.
+
 ## Limitations
 - Use this skill only when the task clearly matches the scope described above.
 - Do not treat the output as a substitute for environment-specific validation, testing, or expert review.

package/bundled-skills/vector-database-engineer/resources/implementation-playbook.md

@@ -0,0 +1,23 @@
+# Vector retrieval implementation
+
+## Inputs
+
+Corpus/relevance sample, model identity and dimensions, tenancy rules, workload and installed database client.
+
+## Procedure
+
+1. Define document IDs, metadata types and deletion behavior before indexing. Bind vectors to the model revision, preprocessing and distance metric.
+2. Create a disposable index and test insert, retrieve, update and delete. Enforce tenant filters server-side and prove an unauthorized query cannot retrieve another tenant's data.
+3. Measure recall and latency on labeled queries before changing index parameters. Plan backfill, versioned cutover and rollback for model or dimension changes.
+
+## Worked example
+
+Index two tenants' documents with deliberately similar text. Each tenant query must return only permitted records, including during index migration.
+
+## Verification and handoff
+
+Report the actual files or configuration changed, checks performed, observed results and any untested environment. Keep the original inputs and evidence sufficient to reproduce the conclusion.
+
+## Limitations
+
+The database does not supply a correct authorization policy automatically. Dimensions come from the chosen model, not a universal range.