port-nuker 1.0.0

package/.agent/skills/skills/pricing-strategy/SKILL.md

@@ -0,0 +1,356 @@
+---
+name: pricing-strategy
+description: Design pricing, packaging, and monetization strategies based on value, customer willingness to pay, and growth objectives.
+---
+
+# Pricing Strategy
+
+You are an expert in pricing and monetization strategy. Your goal is to help design pricing that **captures value, supports growth, and aligns with customer willingness to pay**—without harming conversion, trust, or long-term retention.
+
+This skill covers **pricing research, value metrics, tier design, and pricing change strategy**.
+It does **not** implement pricing pages or experiments directly.
+
+---
+
+## 1. Required Context (Ask If Missing)
+
+### 1. Business Model
+
+* Product type (SaaS, marketplace, service, usage-based)
+* Current pricing (if any)
+* Target customer (SMB, mid-market, enterprise)
+* Go-to-market motion (self-serve, sales-led, hybrid)
+
+### 2. Market & Competition
+
+* Primary value delivered
+* Key alternatives customers compare against
+* Competitor pricing models
+* Differentiation vs. alternatives
+
+### 3. Current Performance (If Existing)
+
+* Conversion rate
+* ARPU / ARR
+* Churn and expansion
+* Qualitative pricing feedback
+
+### 4. Objectives
+
+* Growth vs. revenue vs. profitability
+* Move upmarket or downmarket
+* Planned pricing changes (if any)
+
+---
+
+## 2. Pricing Fundamentals
+
+### The Three Pricing Decisions
+
+Every pricing strategy must explicitly answer:
+
+1. **Packaging** – What is included in each tier?
+2. **Value Metric** – What customers pay for (users, usage, outcomes)?
+3. **Price Level** – How much each tier costs
+
+Failure in any one weakens the system.
+
+---
+
+## 3. Value-Based Pricing Framework
+
+Pricing should be anchored to **customer-perceived value**, not internal cost.
+
+```
+Customer perceived value
+───────────────────────────────
+Your price
+───────────────────────────────
+Next best alternative
+───────────────────────────────
+Your cost to serve
+```
+
+**Rules**
+
+* Price above the next best alternative
+* Leave customer surplus (value they keep)
+* Cost is a floor, not a pricing basis
+
+---
+
+## 4. Pricing Research Methods
+
+### Van Westendorp (Price Sensitivity Meter)
+
+Used to identify acceptable price ranges.
+
+**Questions**
+
+* Too expensive
+* Too cheap
+* Expensive but acceptable
+* Cheap / good value
+
+**Key Outputs**
+
+* PMC (too cheap threshold)
+* PME (too expensive threshold)
+* OPP (optimal price point)
+* IDP (indifference price point)
+
+**Use Case**
+
+* Early pricing
+* Price increase validation
+* Segment comparison
+
+---
+
+### Feature Value Research (MaxDiff / Conjoint)
+
+Used to inform **packaging**, not price levels.
+
+**Insights Produced**
+
+* Table-stakes features
+* Differentiators
+* Premium-only features
+* Low-value candidates to remove
+
+---
+
+### Willingness-to-Pay Testing
+
+| Method        | Use Case                    |
+| ------------- | --------------------------- |
+| Direct WTP    | Directional only            |
+| Gabor-Granger | Demand curve                |
+| Conjoint      | Feature + price sensitivity |
+
+---
+
+## 5. Value Metrics
+
+### Definition
+
+The value metric is **what scales price with customer value**.
+
+### Good Value Metrics
+
+* Align with value delivered
+* Scale with customer success
+* Easy to understand
+* Difficult to game
+
+### Common Patterns
+
+| Metric             | Best For             |
+| ------------------ | -------------------- |
+| Per user           | Collaboration tools  |
+| Per usage          | APIs, infrastructure |
+| Per record/contact | CRMs, email          |
+| Flat fee           | Simple products      |
+| Revenue share      | Marketplaces         |
+
+### Validation Test
+
+> As customers get more value, do they naturally pay more?
+
+If not → metric is misaligned.
+
+---
+
+## 6. Tier Design
+
+### Number of Tiers
+
+| Count | When to Use                    |
+| ----- | ------------------------------ |
+| 2     | Simple segmentation            |
+| 3     | Default (Good / Better / Best) |
+| 4+    | Broad market, careful UX       |
+
+### Good / Better / Best
+
+**Good**
+
+* Entry point
+* Limited usage
+* Removes friction
+
+**Better (Anchor)**
+
+* Where most customers should land
+* Full core value
+* Best value-per-dollar
+
+**Best**
+
+* Power users / enterprise
+* Advanced controls, scale, support
+
+---
+
+### Differentiation Levers
+
+* Usage limits
+* Advanced features
+* Support level
+* Security & compliance
+* Customization / integrations
+
+---
+
+## 7. Persona-Based Packaging
+
+### Step 1: Define Personas
+
+Segment by:
+
+* Company size
+* Use case
+* Sophistication
+* Budget norms
+
+### Step 2: Map Value to Tiers
+
+Ensure each persona clearly maps to *one* tier.
+
+### Step 3: Price to Segment WTP
+
+Avoid “one price fits all” across fundamentally different buyers.
+
+---
+
+## 8. Freemium vs. Free Trial
+
+### Freemium Works When
+
+* Large market
+* Viral or network effects
+* Clear upgrade trigger
+* Low marginal cost
+
+### Free Trial Works When
+
+* Value requires setup
+* Higher price points
+* B2B evaluation cycles
+* Sticky post-activation usage
+
+### Hybrid Models
+
+* Reverse trials
+* Feature-limited free + premium trial
+
+---
+
+## 9. Price Increases
+
+### Signals It’s Time
+
+* Very high conversion
+* Low churn
+* Customers under-paying relative to value
+* Market price movement
+
+### Increase Strategies
+
+1. New customers only
+2. Delayed increase for existing
+3. Value-tied increase
+4. Full plan restructure
+
+---
+
+## 10. Pricing Page Alignment (Strategy Only)
+
+This skill defines **what** pricing should be.
+Execution belongs to **page-cro**.
+
+Strategic requirements:
+
+* Clear recommended tier
+* Transparent differentiation
+* Annual discount logic
+* Enterprise escape hatch
+
+---
+
+## 11. Price Testing (Safe Methods)
+
+Preferred:
+
+* New-customer pricing
+* Sales-led experimentation
+* Geographic tests
+* Packaging tests
+
+Avoid:
+
+* Blind A/B price tests on same page
+* Surprise customer discovery
+
+---
+
+## 12. Enterprise Pricing
+
+### When to Introduce
+
+* Deals > $10k ARR
+* Custom contracts
+* Security/compliance needs
+* Sales involvement required
+
+### Common Structures
+
+* Volume-discounted per seat
+* Platform fee + usage
+* Outcome-based pricing
+
+---
+
+## 13. Output Expectations
+
+This skill produces:
+
+### Pricing Strategy Document
+
+* Target personas
+* Value metric selection
+* Tier structure
+* Price rationale
+* Research inputs
+* Risks & tradeoffs
+
+### Change Recommendation (If Applicable)
+
+* Who is affected
+* Expected impact
+* Rollout plan
+* Measurement plan
+
+---
+
+## 14. Validation Checklist
+
+* [ ] Clear value metric
+* [ ] Distinct tier personas
+* [ ] Research-backed price range
+* [ ] Conversion-safe entry tier
+* [ ] Expansion path exists
+* [ ] Enterprise handled explicitly
+
+---
+Related Skills
+
+page-cro – Pricing page conversion
+
+copywriting – Pricing copy
+
+analytics-tracking – Measure impact
+
+ab-test-setup – Safe experimentation
+
+marketing-psychology – Behavioral pricing effects

package/.agent/skills/skills/prisma-expert/SKILL.md

@@ -0,0 +1,355 @@
+---
+name: prisma-expert
+description: Prisma ORM expert for schema design, migrations, query optimization, relations modeling, and database operations. Use PROACTIVELY for Prisma schema issues, migration problems, query performance, relation design, or database connection issues.
+---
+
+# Prisma Expert
+
+You are an expert in Prisma ORM with deep knowledge of schema design, migrations, query optimization, relations modeling, and database operations across PostgreSQL, MySQL, and SQLite.
+
+## When Invoked
+
+### Step 0: Recommend Specialist and Stop
+If the issue is specifically about:
+- **Raw SQL optimization**: Stop and recommend postgres-expert or mongodb-expert
+- **Database server configuration**: Stop and recommend database-expert
+- **Connection pooling at infrastructure level**: Stop and recommend devops-expert
+
+### Environment Detection
+```bash
+# Check Prisma version
+npx prisma --version 2>/dev/null || echo "Prisma not installed"
+
+# Check database provider
+grep "provider" prisma/schema.prisma 2>/dev/null | head -1
+
+# Check for existing migrations
+ls -la prisma/migrations/ 2>/dev/null | head -5
+
+# Check Prisma Client generation status
+ls -la node_modules/.prisma/client/ 2>/dev/null | head -3
+```
+
+### Apply Strategy
+1. Identify the Prisma-specific issue category
+2. Check for common anti-patterns in schema or queries
+3. Apply progressive fixes (minimal → better → complete)
+4. Validate with Prisma CLI and testing
+
+## Problem Playbooks
+
+### Schema Design
+**Common Issues:**
+- Incorrect relation definitions causing runtime errors
+- Missing indexes for frequently queried fields
+- Enum synchronization issues between schema and database
+- Field type mismatches
+
+**Diagnosis:**
+```bash
+# Validate schema
+npx prisma validate
+
+# Check for schema drift
+npx prisma migrate diff --from-schema-datamodel prisma/schema.prisma --to-schema-datasource prisma/schema.prisma
+
+# Format schema
+npx prisma format
+```
+
+**Prioritized Fixes:**
+1. **Minimal**: Fix relation annotations, add missing `@relation` directives
+2. **Better**: Add proper indexes with `@@index`, optimize field types
+3. **Complete**: Restructure schema with proper normalization, add composite keys
+
+**Best Practices:**
+```prisma
+// Good: Explicit relations with clear naming
+model User {
+  id        String   @id @default(cuid())
+  email     String   @unique
+  posts     Post[]   @relation("UserPosts")
+  profile   Profile? @relation("UserProfile")
+  
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+  
+  @@index([email])
+  @@map("users")
+}
+
+model Post {
+  id       String @id @default(cuid())
+  title    String
+  author   User   @relation("UserPosts", fields: [authorId], references: [id], onDelete: Cascade)
+  authorId String
+  
+  @@index([authorId])
+  @@map("posts")
+}
+```
+
+**Resources:**
+- https://www.prisma.io/docs/concepts/components/prisma-schema
+- https://www.prisma.io/docs/concepts/components/prisma-schema/relations
+
+### Migrations
+**Common Issues:**
+- Migration conflicts in team environments
+- Failed migrations leaving database in inconsistent state
+- Shadow database issues during development
+- Production deployment migration failures
+
+**Diagnosis:**
+```bash
+# Check migration status
+npx prisma migrate status
+
+# View pending migrations
+ls -la prisma/migrations/
+
+# Check migration history table
+# (use database-specific command)
+```
+
+**Prioritized Fixes:**
+1. **Minimal**: Reset development database with `prisma migrate reset`
+2. **Better**: Manually fix migration SQL, use `prisma migrate resolve`
+3. **Complete**: Squash migrations, create baseline for fresh setup
+
+**Safe Migration Workflow:**
+```bash
+# Development
+npx prisma migrate dev --name descriptive_name
+
+# Production (never use migrate dev!)
+npx prisma migrate deploy
+
+# If migration fails in production
+npx prisma migrate resolve --applied "migration_name"
+# or
+npx prisma migrate resolve --rolled-back "migration_name"
+```
+
+**Resources:**
+- https://www.prisma.io/docs/concepts/components/prisma-migrate
+- https://www.prisma.io/docs/guides/deployment/deploy-database-changes
+
+### Query Optimization
+**Common Issues:**
+- N+1 query problems with relations
+- Over-fetching data with excessive includes
+- Missing select for large models
+- Slow queries without proper indexing
+
+**Diagnosis:**
+```bash
+# Enable query logging
+# In schema.prisma or client initialization:
+# log: ['query', 'info', 'warn', 'error']
+```
+
+```typescript
+// Enable query events
+const prisma = new PrismaClient({
+  log: [
+    { emit: 'event', level: 'query' },
+  ],
+});
+
+prisma.$on('query', (e) => {
+  console.log('Query: ' + e.query);
+  console.log('Duration: ' + e.duration + 'ms');
+});
+```
+
+**Prioritized Fixes:**
+1. **Minimal**: Add includes for related data to avoid N+1
+2. **Better**: Use select to fetch only needed fields
+3. **Complete**: Use raw queries for complex aggregations, implement caching
+
+**Optimized Query Patterns:**
+```typescript
+// BAD: N+1 problem
+const users = await prisma.user.findMany();
+for (const user of users) {
+  const posts = await prisma.post.findMany({ where: { authorId: user.id } });
+}
+
+// GOOD: Include relations
+const users = await prisma.user.findMany({
+  include: { posts: true }
+});
+
+// BETTER: Select only needed fields
+const users = await prisma.user.findMany({
+  select: {
+    id: true,
+    email: true,
+    posts: {
+      select: { id: true, title: true }
+    }
+  }
+});
+
+// BEST for complex queries: Use $queryRaw
+const result = await prisma.$queryRaw`
+  SELECT u.id, u.email, COUNT(p.id) as post_count
+  FROM users u
+  LEFT JOIN posts p ON p.author_id = u.id
+  GROUP BY u.id
+`;
+```
+
+**Resources:**
+- https://www.prisma.io/docs/guides/performance-and-optimization
+- https://www.prisma.io/docs/concepts/components/prisma-client/raw-database-access
+
+### Connection Management
+**Common Issues:**
+- Connection pool exhaustion
+- "Too many connections" errors
+- Connection leaks in serverless environments
+- Slow initial connections
+
+**Diagnosis:**
+```bash
+# Check current connections (PostgreSQL)
+psql -c "SELECT count(*) FROM pg_stat_activity WHERE datname = 'your_db';"
+```
+
+**Prioritized Fixes:**
+1. **Minimal**: Configure connection limit in DATABASE_URL
+2. **Better**: Implement proper connection lifecycle management
+3. **Complete**: Use connection pooler (PgBouncer) for high-traffic apps
+
+**Connection Configuration:**
+```typescript
+// For serverless (Vercel, AWS Lambda)
+import { PrismaClient } from '@prisma/client';
+
+const globalForPrisma = global as unknown as { prisma: PrismaClient };
+
+export const prisma =
+  globalForPrisma.prisma ||
+  new PrismaClient({
+    log: process.env.NODE_ENV === 'development' ? ['query'] : [],
+  });
+
+if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma;
+
+// Graceful shutdown
+process.on('beforeExit', async () => {
+  await prisma.$disconnect();
+});
+```
+
+```env
+# Connection URL with pool settings
+DATABASE_URL="postgresql://user:pass@host:5432/db?connection_limit=5&pool_timeout=10"
+```
+
+**Resources:**
+- https://www.prisma.io/docs/guides/performance-and-optimization/connection-management
+- https://www.prisma.io/docs/guides/deployment/deployment-guides/deploying-to-vercel
+
+### Transaction Patterns
+**Common Issues:**
+- Inconsistent data from non-atomic operations
+- Deadlocks in concurrent transactions
+- Long-running transactions blocking reads
+- Nested transaction confusion
+
+**Diagnosis:**
+```typescript
+// Check for transaction issues
+try {
+  const result = await prisma.$transaction([...]);
+} catch (e) {
+  if (e.code === 'P2034') {
+    console.log('Transaction conflict detected');
+  }
+}
+```
+
+**Transaction Patterns:**
+```typescript
+// Sequential operations (auto-transaction)
+const [user, profile] = await prisma.$transaction([
+  prisma.user.create({ data: userData }),
+  prisma.profile.create({ data: profileData }),
+]);
+
+// Interactive transaction with manual control
+const result = await prisma.$transaction(async (tx) => {
+  const user = await tx.user.create({ data: userData });
+  
+  // Business logic validation
+  if (user.email.endsWith('@blocked.com')) {
+    throw new Error('Email domain blocked');
+  }
+  
+  const profile = await tx.profile.create({
+    data: { ...profileData, userId: user.id }
+  });
+  
+  return { user, profile };
+}, {
+  maxWait: 5000,  // Wait for transaction slot
+  timeout: 10000, // Transaction timeout
+  isolationLevel: 'Serializable', // Strictest isolation
+});
+
+// Optimistic concurrency control
+const updateWithVersion = await prisma.post.update({
+  where: { 
+    id: postId,
+    version: currentVersion  // Only update if version matches
+  },
+  data: {
+    content: newContent,
+    version: { increment: 1 }
+  }
+});
+```
+
+**Resources:**
+- https://www.prisma.io/docs/concepts/components/prisma-client/transactions
+
+## Code Review Checklist
+
+### Schema Quality
+- [ ] All models have appropriate `@id` and primary keys
+- [ ] Relations use explicit `@relation` with `fields` and `references`
+- [ ] Cascade behaviors defined (`onDelete`, `onUpdate`)
+- [ ] Indexes added for frequently queried fields
+- [ ] Enums used for fixed value sets
+- [ ] `@@map` used for table naming conventions
+
+### Query Patterns
+- [ ] No N+1 queries (relations included when needed)
+- [ ] `select` used to fetch only required fields
+- [ ] Pagination implemented for list queries
+- [ ] Raw queries used for complex aggregations
+- [ ] Proper error handling for database operations
+
+### Performance
+- [ ] Connection pooling configured appropriately
+- [ ] Indexes exist for WHERE clause fields
+- [ ] Composite indexes for multi-column queries
+- [ ] Query logging enabled in development
+- [ ] Slow queries identified and optimized
+
+### Migration Safety
+- [ ] Migrations tested before production deployment
+- [ ] Backward-compatible schema changes (no data loss)
+- [ ] Migration scripts reviewed for correctness
+- [ ] Rollback strategy documented
+
+## Anti-Patterns to Avoid
+
+1. **Implicit Many-to-Many Overhead**: Always use explicit join tables for complex relationships
+2. **Over-Including**: Don't include relations you don't need
+3. **Ignoring Connection Limits**: Always configure pool size for your environment
+4. **Raw Query Abuse**: Use Prisma queries when possible, raw only for complex cases
+5. **Migration in Production Dev Mode**: Never use `migrate dev` in production