npm - jettypod - Versions diffs - 3.0.1 - Mend

jettypod 3.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (122) hide show

package/.claude/PROTECT_SKILLS.md +28 -0
package/.claude/settings.json +24 -0
package/.claude/settings.local.json +16 -0
package/.claude/skills/epic-discover/SKILL.md +262 -0
package/.claude/skills/feature-discover/SKILL.md +393 -0
package/.claude/skills/speed-mode/SKILL.md +364 -0
package/.claude/skills/stable-mode/SKILL.md +591 -0
package/.github/workflows/test-safety.yml +85 -0
package/README.md +25 -0
package/SPEED-STABLE-AUDIT.md +853 -0
package/SYSTEM-BEHAVIOR.md +1241 -0
package/TEST_SAFETY_AUDIT.md +314 -0
package/TEST_SAFETY_IMPLEMENTATION.md +97 -0
package/cucumber.js +8 -0
package/docs/COMMAND_REFERENCE.md +903 -0
package/docs/DECISIONS.md +68 -0
package/docs/README.md +48 -0
package/docs/STANDARDS-SYSTEM-DOCUMENTATION.md +374 -0
package/docs/TEST-REWRITE-PLAN.md +261 -0
package/docs/ai-test-writing-requirements.md +219 -0
package/docs/claude-code-skills.md +607 -0
package/docs/core-jettypod-methodology/comprehensive-jettypod-methodology.md +582 -0
package/docs/core-jettypod-methodology/deprecated/jettypod-comprehensive-standards.md +1222 -0
package/docs/core-jettypod-methodology/deprecated/jettypod-operating-guide.md +3399 -0
package/docs/core-jettypod-methodology/deprecated/jettypod-technical-checklist.md +1325 -0
package/docs/core-jettypod-methodology/deprecated/jettypod-vibe-coding-framework.md +1544 -0
package/docs/core-jettypod-methodology/deprecated/prompt-engineering-guide.md +320 -0
package/docs/core-jettypod-methodology/deprecated/vibe-coding-cheatsheet (1).md +516 -0
package/docs/core-jettypod-methodology/deprecated/vibe-coding-framework.md +1544 -0
package/docs/features/jettypod-standards-explained.md +543 -0
package/docs/features/standards-inventory.md +257 -0
package/docs/gap-analysis-current-vs-comprehensive-methodology.md +939 -0
package/docs/jettypod-system-overview.md +409 -0
package/features/auto-generate-production-chores.feature +14 -0
package/features/claude-md-protection/steps.js +487 -0
package/features/decisions/index.js +490 -0
package/features/decisions/index.test.js +208 -0
package/features/git-hooks/git-hooks.feature +30 -0
package/features/git-hooks/index.js +93 -0
package/features/git-hooks/index.test.js +137 -0
package/features/git-hooks/post-commit +56 -0
package/features/git-hooks/post-merge +47 -0
package/features/git-hooks/pre-commit +28 -0
package/features/git-hooks/simple-steps.js +53 -0
package/features/git-hooks/simple-test.feature +10 -0
package/features/git-hooks/steps.js +196 -0
package/features/jettypod-update-command.feature +46 -0
package/features/mode-prompts/index.js +95 -0
package/features/mode-prompts/simple-steps.js +44 -0
package/features/mode-prompts/simple-test.feature +9 -0
package/features/mode-prompts/validation.test.js +120 -0
package/features/refactor-mode/steps.js +217 -0
package/features/refactor-mode.feature +49 -0
package/features/skills-update/index.test.js +216 -0
package/features/step_definitions/auto-generate-production-chores.steps.js +162 -0
package/features/step_definitions/terminal-logo.steps.js +145 -0
package/features/step_definitions/update-command.steps.js +183 -0
package/features/terminal-logo/index.js +39 -0
package/features/terminal-logo/terminal-logo.feature +30 -0
package/features/update-command/index.js +181 -0
package/features/update-command/index.test.js +225 -0
package/features/work-commands/bug-workflow-display.feature +22 -0
package/features/work-commands/index.js +311 -0
package/features/work-commands/simple-steps.js +69 -0
package/features/work-commands/stable-tests.feature +57 -0
package/features/work-commands/steps.js +1120 -0
package/features/work-commands/validation.test.js +88 -0
package/features/work-commands/work-commands.feature +13 -0
package/features/work-tracking/discovery-validation.test.js +228 -0
package/features/work-tracking/index.js +1511 -0
package/features/work-tracking/mode-required.feature +112 -0
package/features/work-tracking/phase-tracking.test.js +482 -0
package/features/work-tracking/prototype-tracking.test.js +485 -0
package/features/work-tracking/tree-view.test.js +310 -0
package/features/work-tracking/work-set-mode.feature +71 -0
package/features/work-tracking/work-start-mode.feature +88 -0
package/full-test.txt +0 -0
package/install.sh +89 -0
package/jettypod.js +1640 -0
package/lib/bug-workflow.js +94 -0
package/lib/bug-workflow.test.js +177 -0
package/lib/claudemd.js +130 -0
package/lib/claudemd.test.js +195 -0
package/lib/comprehensive-standards-full.json +1778 -0
package/lib/config.js +181 -0
package/lib/config.test.js +511 -0
package/lib/constants.js +107 -0
package/lib/constants.test.js +164 -0
package/lib/current-work.js +130 -0
package/lib/current-work.test.js +146 -0
package/lib/database-project-config.test.js +107 -0
package/lib/database.js +256 -0
package/lib/database.test.js +106 -0
package/lib/decisions-generator.js +102 -0
package/lib/decisions-generator.test.js +457 -0
package/lib/decisions-helpers.js +119 -0
package/lib/decisions-helpers.test.js +310 -0
package/lib/discovery-checkpoint.js +83 -0
package/lib/docs-generator.js +280 -0
package/lib/external-checklist.js +177 -0
package/lib/git.js +142 -0
package/lib/git.test.js +145 -0
package/lib/logo.js +3 -0
package/lib/migrations/001-epic-to-parent.js +24 -0
package/lib/migrations/002-default-work-item-modes.js +37 -0
package/lib/migrations/002-default-work-item-modes.test.js +351 -0
package/lib/migrations/003-epic-discovery-fields.js +52 -0
package/lib/migrations/004-discovery-decisions-table.js +32 -0
package/lib/migrations/005-migrate-decision-data.js +62 -0
package/lib/migrations/006-feature-phase-field.js +61 -0
package/lib/migrations/007-prototype-tracking.js +38 -0
package/lib/migrations/008-scenario-file-field.js +24 -0
package/lib/migrations/index.js +74 -0
package/lib/production-helpers.js +69 -0
package/lib/project-state.test.js +92 -0
package/lib/test-helpers.js +184 -0
package/lib/test-helpers.test.js +255 -0
package/package.json +36 -0
package/prototypes/test/index.html +1 -0
package/setup-dist-repo.sh +68 -0
package/test-safety-check.sh +80 -0
package/work-item-tracking-plan.md +199 -0

package/docs/core-jettypod-methodology/deprecated/jettypod-technical-checklist.md ADDED Viewed

@@ -0,0 +1,1325 @@
+# The Vibe Coding Operating System: Complete Technical Cheat Sheet
+## 🎯 QUICK MODE SELECTOR
+```
+CLARITY CHECK:                     RISK CHECK:
+□ Know exactly what to build?      □ Real users depend on this?
+□ Have clear success criteria?     □ Handling sensitive/financial data?
+□ Built similar before?            □ Hard to fix if wrong?
+0-1 Risk + Low Clarity → Discovery Mode
+0-1 Risk + High Clarity → Speed Mode
+2-3 Risk + High Clarity → Production Mode
+2-3 Risk + Low Clarity → STOP! Discovery first
+Something broken → Recovery Mode (always)
+```
+---
+# 🚀 USE CASE 1: STARTING A NEW PROJECT
+## 🔍 DISCOVERY MODE: "I don't know what I'm building"
+**TECHNICAL MUST DO:**
+- [ ]  Create 3+ HTML/React prototypes
+- [ ]  Use fake data (`const mockData = [...]`)
+- [ ]  Try different UI libraries (Material-UI vs Tailwind)
+- [ ]  Test localStorage vs IndexedDB
+- [ ]  Compare REST vs GraphQL approaches
+- [ ]  Build kanban vs list vs table views
+**EXAMPLE APPROACHES TO TEST:**
+```jsx
+// Approach 1: Client-side everything
+const App = () => {
+  const [data, setData] = useState(mockData);
+  return <div>{/* All logic in React */}</div>;
+};
+// Approach 2: Backend-driven
+const App = () => {
+  const data = await fetch('/api/data');
+  return <div>{/* Thin client */}</div>;
+};
+// Approach 3: Hybrid
+const App = () => {
+  const cache = localStorage.getItem('data');
+  const fresh = await fetch('/api/sync');
+  return <div>{/* Smart sync */}</div>;
+};
+```
+**PROMPT TEMPLATE:**
+```
+"Show me 3 different ways to build [concept]:
+1. Simplest possible
+2. Most user-friendly
+3. Most scalable
+Create interactive mockups I can click through"
+```
+## 🏃 SPEED MODE: "I know what I want, just build it"
+**TECHNICAL MUST DO:**
+- [ ]  Single HTML/React file to start
+- [ ]  Use localStorage instead of database
+- [ ]  Inline styles or Tailwind CDN
+- [ ]  `useState` for all state management
+- [ ]  Hardcoded data for testing
+- [ ]  `console.log` for debugging
+- [ ]  Working version in 1 hour max
+**SPEED MODE SETUP:**
+```html
+<!-- Single file start -->
+<!DOCTYPE html>
+<html>
+<head>
+  <script src="<https://unpkg.com/react@18/umd/react.development.js>"></script>
+  <script src="<https://unpkg.com/react-dom@18/umd/react-dom.development.js>"></script>
+  <script src="<https://cdn.tailwindcss.com>"></script>
+</head>
+<body>
+  <div id="root"></div>
+  <script type="text/babel">
+    const App = () => {
+      const [items, setItems] = useState(
+        JSON.parse(localStorage.getItem('items') || '[]')
+      );
+      return (
+        <div className="p-4">
+          {/* Build entire app here */}
+        </div>
+      );
+    };
+  </script>
+</body>
+</html>
+```
+**TECHNICAL AVOID:**
+- ❌ Microservices/message queues
+- ❌ Database setup on day 1
+- ❌ Redux/complex state management
+- ❌ Docker/Kubernetes
+- ❌ GraphQL/complex APIs
+- ❌ OAuth/complex auth
+## 🛡️ PRODUCTION MODE: "This needs to be bulletproof"
+**TECHNICAL MUST DO:**
+- [ ]  Use Auth0/Clerk/Supabase Auth (never custom)
+- [ ]  Environment variables from start (.env, .env.local)
+- [ ]  Sentry error tracking setup
+- [ ]  Database migrations (Prisma/Knex)
+- [ ]  Input validation (Zod/Yup)
+- [ ]  HTTPS only
+- [ ]  CORS configuration
+- [ ]  Rate limiting
+**PRODUCTION SETUP:**
+```jsx
+// Project structure
+/app
+  /pages
+  /components
+  /lib
+    /auth
+    /db
+    /validation
+/api
+  /routes
+  /middleware
+  /services
+/tests
+  /unit
+  /integration
+  /e2e
+// Environment setup
+// .env.local
+DATABASE_URL=postgresql://...
+AUTH_SECRET=generated-secret-key
+SENTRY_DSN=https://...
+STRIPE_SECRET_KEY=sk_test_...
+// Never hardcode secrets
+const apiKey = process.env.API_KEY; // ✅
+const apiKey = "sk_live_abc123"; // ❌ NEVER
+// Input validation from day 1
+import { z } from 'zod';
+const userSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(8),
+  age: z.number().min(13).max(120),
+});
+// Database with migrations
+npx prisma init
+npx prisma migrate dev
+```
+## 🚨 RECOVERY MODE: "Oh shit, I need to start over"
+**WHEN THIS HAPPENS:**
+- Can't figure out what you're building after weeks
+- Technical debt is overwhelming
+- Starting fresh would be faster than fixing
+**RECOVERY ACTIONS:**
+```bash
+# Save what works
+git stash
+git branch backup-old-attempt
+# Extract the good parts
+mkdir new-project
+cp old-project/components/WorkingFeature.js new-project/
+cp old-project/utils/useful-helpers.js new-project/
+# Start fresh with lessons learned
+npx create-next-app@latest new-project
+```
+---
+# 🔨 USE CASE 2: BUILDING NEW FEATURES
+## 🔍 DISCOVERY MODE: "Not sure how this fits"
+**TECHNICAL MUST DO:**
+- [ ]  `console.log` existing data structures
+- [ ]  Map component dependencies
+- [ ]  Try 2-3 implementation approaches
+- [ ]  Test with different data sizes (10 vs 10,000)
+- [ ]  Check render performance with React DevTools
+**DISCOVERY PATTERNS:**
+```jsx
+// Understanding integration points
+console.log('Current data structure:', data);
+console.log('Props received:', props);
+console.log('State before update:', state);
+// Try different approaches
+// Option 1: Optimistic updates
+const handleSave = () => {
+  setData(newData); // Update immediately
+  api.save(newData).catch(() => setData(oldData)); // Rollback if fails
+};
+// Option 2: Pessimistic updates
+const handleSave = async () => {
+  setLoading(true);
+  await api.save(newData);
+  setData(newData); // Update after success
+  setLoading(false);
+};
+// Option 3: Hybrid with status
+const handleSave = () => {
+  setData({...newData, status: 'pending'});
+  api.save(newData)
+    .then(() => setData({...newData, status: 'saved'}))
+    .catch(() => setData({...oldData, status: 'error'}));
+};
+```
+## 🏃 SPEED MODE: "Just add the button"
+**TECHNICAL MUST DO:**
+- [ ]  Add feature as new component/function
+- [ ]  Use existing data structures
+- [ ]  Read-only features first
+- [ ]  Test with `console.log`
+**ISOLATED FEATURE PATTERN:**
+```jsx
+// Good: Self-contained feature
+const ExportButton = ({ data }) => {
+  const handleExport = () => {
+    const csv = data
+      .map(row => `${row.date},${row.amount},${row.description}`)
+      .join('\\n');
+    const blob = new Blob([csv], { type: 'text/csv' });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = 'export.csv';
+    a.click();
+  };
+  return <button onClick={handleExport}>Export CSV</button>;
+};
+// Add to existing component
+<div>
+  {/* existing code */}
+  <ExportButton data={expenses} />
+</div>
+```
+## 🛡️ PRODUCTION MODE: "This touches payments"
+**TECHNICAL MUST DO:**
+- [ ]  Write tests first → make tests pass with minimal code → refactor (TDD)
+- [ ]  Use transactions for database operations
+- [ ]  Add idempotency keys for payments
+- [ ]  Implement retry logic with exponential backoff
+- [ ]  Add audit logging
+- [ ]  Use feature flags
+**PRODUCTION FEATURE IMPLEMENTATION:**
+```jsx
+// Test first
+describe('Subscription Feature', () => {
+  test('handles successful payment', async () => {
+    const result = await processSubscription(validCard);
+    expect(result.status).toBe('active');
+    expect(auditLog).toHaveBeenCalledWith({
+      action: 'subscription_created',
+      userId: expect.any(String),
+    });
+  });
+  test('handles declined card', async () => {
+    const result = await processSubscription(declinedCard);
+    expect(result.status).toBe('failed');
+    expect(customer.notified).toBe(true);
+  });
+});
+// Implementation with all safeguards
+const processSubscription = async (paymentMethod) => {
+  const idempotencyKey = generateIdempotencyKey();
+  return await db.transaction(async (trx) => {
+    try {
+      // Create Stripe subscription
+      const subscription = await stripe.subscriptions.create({
+        customer: customerId,
+        items: [{ price: priceId }],
+        payment_method: paymentMethod,
+        idempotency_key: idempotencyKey,
+      });
+      // Update database
+      await trx('subscriptions').insert({
+        user_id: userId,
+        stripe_subscription_id: subscription.id,
+        status: subscription.status,
+      });
+      // Audit log
+      await trx('audit_logs').insert({
+        action: 'subscription_created',
+        user_id: userId,
+        metadata: { subscription_id: subscription.id },
+      });
+      return { success: true, subscription };
+    } catch (error) {
+      logger.error('Subscription failed', {
+        error: error.message,
+        userId,
+        idempotencyKey,
+      });
+      throw new Error('Payment processing failed');
+    }
+  });
+};
+```
+## 🚨 RECOVERY MODE: "The new feature broke everything"
+**IMMEDIATE ACTIONS:**
+```jsx
+// 1. Feature flag to disable
+if (process.env.ENABLE_NEW_FEATURE === 'true') {
+  return <NewFeature />;
+} else {
+  return <OldFeature />;
+}
+// 2. Quick patch
+try {
+  return riskyNewFeature();
+} catch (error) {
+  console.error('New feature failed, falling back', error);
+  return oldReliableFeature();
+}
+// 3. Circuit breaker
+let failures = 0;
+const featureWithCircuitBreaker = () => {
+  if (failures > 3) {
+    return null; // Don't render if failing
+  }
+  try {
+    return <NewFeature />;
+  } catch (error) {
+    failures++;
+    setTimeout(() => failures--, 60000); // Reset after 1 min
+    return null;
+  }
+};
+```
+---
+# 🔧 USE CASE 3: REFACTORING
+## 🔍 DISCOVERY MODE: "What is this code even doing?"
+**TECHNICAL MUST DO:**
+- [ ]  Add JSDoc comments first
+- [ ]  Log all function inputs/outputs
+- [ ]  Create characterization tests
+- [ ]  Use `git diff` to track changes
+- [ ]  Keep both implementations temporarily
+**UNDERSTANDING MESSY CODE:**
+```jsx
+// Step 1: Add explanatory comments
+function mysteryFunction(x, y, z) {
+  // Log to understand
+  console.log('Inputs:', { x, y, z });
+  const a = x * 2 + y; // TODO: Why multiply by 2?
+  console.log('Intermediate a:', a);
+  const b = z ? a / z : a; // Avoid division by zero
+  console.log('Result b:', b);
+  return b > 100 ? 100 : b; // Cap at 100
+}
+// Step 2: Write tests to document behavior
+test('mystery function behavior', () => {
+  expect(mysteryFunction(10, 5, 2)).toBe(12.5);
+  expect(mysteryFunction(10, 5, 0)).toBe(25); // Doesn't divide
+  expect(mysteryFunction(100, 100, 1)).toBe(100); // Caps at 100
+});
+// Step 3: Refactor with confidence
+function calculateAdjustedScore(base, bonus, divisor) {
+  const rawScore = base * 2 + bonus;
+  const adjustedScore = divisor ? rawScore / divisor : rawScore;
+  return Math.min(adjustedScore, 100);
+}
+```
+## 🏃 SPEED MODE: "Quick cleanup"
+**TECHNICAL MUST DO:**
+- [ ]  Extract components (500+ lines)
+- [ ]  Rename variables for clarity
+- [ ]  Create folders by feature
+- [ ]  Move utils to separate file
+**QUICK REFACTOR PATTERNS:**
+```jsx
+// Before: 500 line component
+const App = () => {
+  // ... 500 lines of mixed concerns
+};
+// After: Organized by feature
+/features
+  /expenses
+    ExpenseList.js
+    ExpenseForm.js
+    expenseUtils.js
+  /auth
+    LoginForm.js
+    useAuth.js
+  /shared
+    Button.js
+    Modal.js
+// Simple extraction
+// Before: Inline complex logic
+const Component = () => {
+  const result = data
+    .filter(x => x.active)
+    .map(x => ({...x, tax: x.amount * 0.1}))
+    .reduce((sum, x) => sum + x.amount + x.tax, 0);
+};
+// After: Named function
+const calculateTotalWithTax = (data) => {
+  const TAX_RATE = 0.1;
+  return data
+    .filter(item => item.active)
+    .map(item => ({...item, tax: item.amount * TAX_RATE}))
+    .reduce((sum, item) => sum + item.amount + item.tax, 0);
+};
+const Component = () => {
+  const result = calculateTotalWithTax(data);
+};
+```
+## 🛡️ PRODUCTION MODE: "Refactoring critical path"
+**TECHNICAL MUST DO:**
+- [ ]  Comprehensive test coverage first
+- [ ]  Performance baseline measured
+- [ ]  Run old+new in parallel
+- [ ]  Gradual migration with feature flags
+- [ ]  Monitor during transition
+**SAFE PRODUCTION REFACTOR:**
+```jsx
+// Step 1: Measure current performance
+console.time('oldImplementation');
+const oldResult = oldFunction(data);
+console.timeEnd('oldImplementation'); // Baseline: 450ms
+// Step 2: Comprehensive tests
+describe('Payment Processing', () => {
+  const testCases = [
+    { input: normalPayment, expected: 'success' },
+    { input: declinedCard, expected: 'declined' },
+    { input: expiredCard, expected: 'expired' },
+    // ... 20+ test cases
+  ];
+  testCases.forEach(({ input, expected }) => {
+    test(`handles ${expected}`, () => {
+      expect(oldFunction(input).status).toBe(expected);
+    });
+  });
+});
+// Step 3: Parallel implementation
+const processPayment = async (data) => {
+  const useNewImplementation = await featureFlag.isEnabled('new-payment-flow');
+  if (useNewImplementation) {
+    // Monitor new implementation
+    const start = Date.now();
+    const result = await newPaymentFlow(data);
+    metrics.record('new_payment_duration', Date.now() - start);
+    // Shadow mode: run old one too for comparison
+    if (config.shadowMode) {
+      const oldResult = await oldPaymentFlow(data);
+      if (result.status !== oldResult.status) {
+        logger.warn('Payment flow mismatch', { old: oldResult, new: result });
+      }
+    }
+    return result;
+  }
+  return oldPaymentFlow(data);
+};
+// Step 4: Gradual rollout
+// Day 1: 1% of users
+// Day 3: 10% of users
+// Day 7: 50% of users
+// Day 14: 100% of users
+```
+## 🚨 RECOVERY MODE: "Refactoring broke production"
+**ROLLBACK PROCEDURES:**
+```bash
+# Immediate rollback
+git revert HEAD
+git push origin main --force-with-lease
+# Or feature flag disable
+curl -X POST <https://api.launchdarkly.com/flags/new-refactor/off>
+# Database rollback if needed
+psql $DATABASE_URL -c "
+  ALTER TABLE users RENAME COLUMN new_field TO new_field_backup;
+  ALTER TABLE users RENAME COLUMN old_field_backup TO old_field;
+"
+```
+---
+# 🧪 USE CASE 4: TESTING
+## 🔍 DISCOVERY MODE: "Learning through tests"
+**TECHNICAL MUST DO:**
+- [ ]  Test edge cases to understand
+- [ ]  Use `.toMatchSnapshot()` for complex outputs
+- [ ]  Test with boundary values
+- [ ]  Log intermediate values
+**CHARACTERIZATION TESTING:**
+```jsx
+// Discovering what existing code does
+describe('Legacy Calculator', () => {
+  // Test various inputs to understand behavior
+  test('exploring edge cases', () => {
+    console.log(calculate(0));        // => 0
+    console.log(calculate(-1));       // => throws error
+    console.log(calculate(0.1));      // => 0.11 (weird!)
+    console.log(calculate(999999));   // => 100 (capped?)
+    console.log(calculate(null));     // => 0 (coercion)
+    console.log(calculate('5'));      // => 5.5 (string coercion)
+  });
+  // Document the discovered behavior
+  test('actual behavior', () => {
+    expect(calculate(0)).toBe(0);
+    expect(() => calculate(-1)).toThrow();
+    expect(calculate(0.1)).toBeCloseTo(0.11);
+    expect(calculate(999999)).toBe(100);
+    expect(calculate(null)).toBe(0);
+  });
+});
+```
+## 🏃 SPEED MODE: "Just test the math"
+**TECHNICAL MUST DO:**
+- [ ]  Test calculations only
+- [ ]  Simple Jest/Vitest tests
+- [ ]  Skip UI tests
+- [ ]  Manual testing is fine
+**MINIMAL TEST SUITE:**
+```jsx
+// Only test critical business logic
+describe('Invoice Calculator', () => {
+  test('calculates subtotal', () => {
+    const items = [
+      { price: 10, quantity: 2 },
+      { price: 5, quantity: 3 },
+    ];
+    expect(calculateSubtotal(items)).toBe(35);
+  });
+  test('applies discount', () => {
+    expect(applyDiscount(100, 0.1)).toBe(90);
+    expect(applyDiscount(100, 0)).toBe(100);
+  });
+  test('calculates tax', () => {
+    expect(calculateTax(100, 0.08)).toBe(8);
+  });
+});
+// Skip these in Speed Mode:
+// - Component rendering tests
+// - API integration tests
+// - E2E tests
+// - Visual regression tests
+```
+## 🛡️ PRODUCTION MODE: "Test everything"
+**TECHNICAL MUST DO:**
+- [ ]  Unit tests with Jest/Vitest
+- [ ]  Integration tests with Supertest
+- [ ]  E2E tests with Playwright
+- [ ]  Load testing with k6
+- [ ]  Property-based tests for calculations
+**COMPREHENSIVE TEST PYRAMID:**
+```jsx
+// 1. Unit Tests (70%)
+describe('User Service', () => {
+  test('creates user with valid data', async () => {
+    const user = await createUser(validData);
+    expect(user).toHaveProperty('id');
+    expect(user.email).toBe(validData.email);
+  });
+  test('rejects invalid email', async () => {
+    await expect(createUser({ email: 'invalid' }))
+      .rejects.toThrow('Invalid email');
+  });
+});
+// 2. Integration Tests (20%)
+describe('API Endpoints', () => {
+  test('POST /users creates user', async () => {
+    const response = await request(app)
+      .post('/api/users')
+      .send({ email: 'test@test.com', password: 'Test123!' })
+      .expect(201);
+    expect(response.body).toHaveProperty('id');
+    expect(mockDatabase.users).toHaveLength(1);
+    expect(mockEmailService).toHaveBeenCalled();
+  });
+});
+// 3. E2E Tests (10%)
+test('Complete user journey', async ({ page }) => {
+  await page.goto('/signup');
+  await page.fill('[name=email]', 'test@test.com');
+  await page.fill('[name=password]', 'Test123!');
+  await page.click('button[type=submit]');
+  await expect(page).toHaveURL('/dashboard');
+  await expect(page.locator('h1')).toContainText('Welcome');
+});
+// 4. Property-Based Tests
+import fc from 'fast-check';
+test('discount never makes price negative', () => {
+  fc.assert(
+    fc.property(
+      fc.float({ min: 0, max: 1000000 }),
+      fc.float({ min: 0, max: 1 }),
+      (price, discountRate) => {
+        const final = applyDiscount(price, discountRate);
+        expect(final).toBeGreaterThanOrEqual(0);
+        expect(final).toBeLessThanOrEqual(price);
+      }
+    )
+  );
+});
+// 5. Load Tests (k6)
+export default function() {
+  const response = http.get('<https://api.example.com/users>');
+  check(response, {
+    'status is 200': (r) => r.status === 200,
+    'response time < 500ms': (r) => r.timings.duration < 500,
+  });
+}
+export const options = {
+  stages: [
+    { duration: '2m', target: 100 }, // Ramp up
+    { duration: '5m', target: 100 }, // Stay at 100 users
+    { duration: '2m', target: 0 },   // Ramp down
+  ],
+  thresholds: {
+    http_req_duration: ['p(95)<500'], // 95% of requests under 500ms
+  },
+};
+```
+## 🚨 RECOVERY MODE: "Tests are failing in CI"
+**DEBUGGING CI FAILURES:**
+```jsx
+// Add debugging for CI-only failures
+test('flaky test', async () => {
+  // Add verbose logging
+  console.log('Environment:', process.env.NODE_ENV);
+  console.log('Database URL:', process.env.DATABASE_URL?.substring(0, 20));
+  // Increase timeouts for CI
+  jest.setTimeout(10000);
+  // Add retries for flaky network
+  let attempts = 0;
+  while (attempts < 3) {
+    try {
+      const result = await apiCall();
+      expect(result).toBeDefined();
+      break;
+    } catch (error) {
+      attempts++;
+      if (attempts === 3) throw error;
+      await new Promise(r => setTimeout(r, 1000));
+    }
+  }
+  // Screenshot on failure (Playwright)
+  try {
+    await expect(page.locator('.success')).toBeVisible();
+  } catch (error) {
+    await page.screenshot({ path: 'test-failure.png' });
+    throw error;
+  }
+});
+```
+---
+# 🐛 USE CASE 5: DEBUGGING
+## 🔍 DISCOVERY MODE: "Why is this slow sometimes?"
+**TECHNICAL MUST DO:**
+- [ ]  Add performance.now() timers
+- [ ]  Use Chrome Performance profiler
+- [ ]  Check Network waterfall
+- [ ]  Add data size logging
+- [ ]  Test on slow 3G throttling
+**PERFORMANCE INVESTIGATION:**
+```jsx
+// Add timing to understand bottlenecks
+const debug = async (operation, data) => {
+  console.group(`Debug: ${operation}`);
+  console.log('Data size:', JSON.stringify(data).length);
+  console.log('Item count:', Array.isArray(data) ? data.length : 'N/A');
+  console.time('Operation duration');
+  const start = performance.now();
+  const result = await performOperation(data);
+  const duration = performance.now() - start;
+  console.timeEnd('Operation duration');
+  if (duration > 1000) {
+    console.warn(`Slow operation detected: ${duration}ms`);
+    console.trace(); // Show call stack
+  }
+  console.log('Memory:', performance.memory?.usedJSHeapSize);
+  console.groupEnd();
+  return result;
+};
+// Profile specific users
+if (user.hasPerformanceIssues) {
+  window.enableProfiling = true;
+  console.profile('UserInteraction');
+  // ... user interactions
+  console.profileEnd();
+}
+```
+## 🏃 SPEED MODE: "Quick fix"
+**TECHNICAL MUST DO:**
+- [ ]  `console.log` before errors
+- [ ]  Add `|| []` for undefined arrays
+- [ ]  Use `?.` optional chaining
+- [ ]  Quick try/catch wrapping
+**COMMON QUICK FIXES:**
+```jsx
+// Fix: Cannot read property of undefined
+// Before
+const name = user.profile.name; // Crashes if profile undefined
+// After
+const name = user?.profile?.name || 'Anonymous';
+// Fix: map is not a function
+// Before
+items.map(item => ...) // Crashes if items not array
+// After
+(items || []).map(item => ...)
+// or
+Array.isArray(items) && items.map(item => ...)
+// Fix: Async errors not caught
+// Before
+async function risky() {
+  const data = await fetch('/api');
+  return data.json();
+}
+// After
+async function safe() {
+  try {
+    const data = await fetch('/api');
+    return await data.json();
+  } catch (error) {
+    console.error('API failed:', error);
+    return { error: 'Failed to load data' };
+  }
+}
+// Fix: State update on unmounted component
+useEffect(() => {
+  let mounted = true;
+  fetchData().then(data => {
+    if (mounted) {
+      setData(data);
+    }
+  });
+  return () => { mounted = false; };
+}, []);
+```
+## 🛡️ PRODUCTION MODE: "Systematic debugging"
+**TECHNICAL MUST DO:**
+- [ ]  Structured logging (winston/pino)
+- [ ]  Correlation IDs for request tracking
+- [ ]  APM tools (DataDog/New Relic)
+- [ ]  Database query analysis
+- [ ]  Distributed tracing
+**PRODUCTION DEBUGGING SETUP:**
+```jsx
+// Structured logging with context
+import pino from 'pino';
+const logger = pino({
+  level: process.env.LOG_LEVEL || 'info',
+  formatters: {
+    bindings: (bindings) => ({
+      pid: bindings.pid,
+      hostname: bindings.hostname,
+      node_version: process.version,
+    }),
+  },
+});
+// Request middleware with correlation ID
+app.use((req, res, next) => {
+  req.id = crypto.randomUUID();
+  req.logger = logger.child({ requestId: req.id });
+  req.logger.info({
+    method: req.method,
+    url: req.url,
+    ip: req.ip,
+    userAgent: req.get('user-agent'),
+  });
+  next();
+});
+// Trace database queries
+const db = knex({
+  client: 'postgresql',
+  connection: DATABASE_URL,
+  pool: { min: 2, max: 10 },
+  debug: process.env.NODE_ENV === 'development',
+  postProcessResponse: (result, queryContext) => {
+    logger.debug({
+      query: queryContext.sql,
+      bindings: queryContext.bindings,
+      duration: queryContext.duration,
+      rows: result?.length,
+    });
+    return result;
+  },
+});
+// Error tracking with context
+app.use((err, req, res, next) => {
+  const errorId = crypto.randomUUID();
+  req.logger.error({
+    errorId,
+    error: {
+      message: err.message,
+      stack: err.stack,
+      code: err.code,
+    },
+    request: {
+      method: req.method,
+      url: req.url,
+      headers: req.headers,
+      body: req.body, // Be careful with sensitive data
+    },
+    user: req.user?.id,
+  });
+  // Send to Sentry with context
+  Sentry.captureException(err, {
+    tags: {
+      errorId,
+      requestId: req.id,
+    },
+    user: {
+      id: req.user?.id,
+    },
+    extra: {
+      url: req.url,
+      method: req.method,
+    },
+  });
+  res.status(500).json({
+    error: 'Internal server error',
+    errorId, // User can reference this for support
+  });
+});
+```
+## 🚨 RECOVERY MODE: "Production is on fire"
+**EMERGENCY DEBUGGING:**
+```jsx
+// 1. Emergency circuit breaker
+const CircuitBreaker = require('opossum');
+const options = {
+  timeout: 3000,
+  errorThresholdPercentage: 50,
+  resetTimeout: 30000,
+};
+const breaker = new CircuitBreaker(dangerousFunction, options);
+breaker.on('open', () => {
+  logger.error('Circuit breaker opened - using fallback');
+});
+breaker.fallback(() => {
+  return { cached: true, data: lastKnownGood };
+});
+// 2. Database query killer
+-- Find slow queries
+SELECT pid, now() - pg_stat_activity.query_start AS duration, query
+FROM pg_stat_activity
+WHERE (now() - pg_stat_activity.query_start) > interval '5 minutes';
+-- Kill specific query
+SELECT pg_terminate_backend(PID);
+-- Kill all queries from specific user
+SELECT pg_terminate_backend(pid)
+FROM pg_stat_activity
+WHERE usename = 'app_user' AND pid != pg_backend_pid();
+// 3. Memory leak detection
+const v8 = require('v8');
+const fs = require('fs');
+// Take heap snapshot
+const writeHeapSnapshot = () => {
+  const filename = `heap-${Date.now()}.heapsnapshot`;
+  const stream = v8.writeHeapSnapshot();
+  stream.pipe(fs.createWriteStream(filename));
+  logger.info(`Heap snapshot written to ${filename}`);
+};
+// Monitor memory growth
+setInterval(() => {
+  const usage = process.memoryUsage();
+  logger.info({
+    memory: {
+      rss: Math.round(usage.rss / 1024 / 1024) + 'MB',
+      heapTotal: Math.round(usage.heapTotal / 1024 / 1024) + 'MB',
+      heapUsed: Math.round(usage.heapUsed / 1024 / 1024) + 'MB',
+      external: Math.round(usage.external / 1024 / 1024) + 'MB',
+    }
+  });
+  // Emergency dump if memory too high
+  if (usage.heapUsed > 500 * 1024 * 1024) {
+    writeHeapSnapshot();
+    // Optionally restart
+    // process.exit(1);
+  }
+}, 60000);
+```
+---
+# 🚢 USE CASE 6: DEPLOYMENT
+## 🔍 DISCOVERY MODE: "How do I put this online?"
+**EXPLORE OPTIONS:**
+```jsx
+// Option 1: Static hosting (frontend only)
+// Netlify, Vercel, GitHub Pages
+// Cost: $0
+// Good for: Portfolio, docs, SPAs
+npm run build
+# Drag 'build' folder to Netlify
+// Option 2: Serverless
+// Vercel, Netlify Functions, AWS Lambda
+// Cost: $0-20/month
+// Good for: APIs, simple backends
+export default function handler(req, res) {
+  res.status(200).json({ data });
+}
+// Option 3: Platform-as-a-Service
+// Railway, Render, Heroku
+// Cost: $5-50/month
+// Good for: Full-stack apps
+{
+  "scripts": {
+    "start": "node server.js"
+  }
+}
+// Option 4: VPS
+// DigitalOcean, Linode
+// Cost: $5-40/month
+// Good for: Multiple apps, full control
+ssh root@server
+apt update && apt install nodejs
+```
+## 🏃 SPEED MODE: "Just ship it"
+**QUICKEST DEPLOYMENT:**
+```bash
+# Frontend only - Netlify Drop
+1. npm run build
+2. Go to app.netlify.com/drop
+3. Drag 'build' folder
+4. Done! Live URL in seconds
+# Full-stack - Railway
+1. Push to GitHub
+2. Connect Railway to repo
+3. Add environment variables
+4. Deploy! Auto-deploys on push
+# Quick environment setup
+echo "DATABASE_URL=postgres://..." > .env
+echo ".env" >> .gitignore
+git push
+```
+## 🛡️ PRODUCTION MODE: "Zero-downtime deployment"
+**PRODUCTION DEPLOYMENT SETUP:**
+```jsx
+// 1. Multiple environments
+// .github/workflows/deploy.yml
+name: Deploy
+on:
+  push:
+    branches: [main, staging]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - run: npm test
+  deploy-staging:
+    if: github.ref == 'refs/heads/staging'
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+      - run: npm run deploy:staging
+  deploy-production:
+    if: github.ref == 'refs/heads/main'
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+      - run: npm run deploy:production
+// 2. Blue-green deployment
+const blueGreenDeploy = async () => {
+  // Deploy to green environment
+  await deployToGreen();
+  // Health check
+  const healthy = await healthCheck('green');
+  if (!healthy) {
+    throw new Error('Green deployment unhealthy');
+  }
+  // Switch traffic
+  await updateLoadBalancer('green');
+  // Monitor
+  await sleep(5 * 60 * 1000);
+  // Keep blue as backup
+  console.log('Deployment successful');
+};
+// 3. Database migrations (safe)
+-- Step 1: Add column (backward compatible)
+ALTER TABLE users ADD COLUMN email_verified BOOLEAN DEFAULT false;
+-- Step 2: Deploy code that writes both old and new
+await db.users.update({
+  verified: true,        // old column
+  email_verified: true,  // new column
+});
+-- Step 3: Backfill data
+UPDATE users SET email_verified = verified WHERE email_verified IS NULL;
+-- Step 4: Deploy code that reads from new column
+const isVerified = user.email_verified;
+-- Step 5: Drop old column (after all deploys)
+ALTER TABLE users DROP COLUMN verified;
+// 4. Feature flags for gradual rollout
+if (await featureFlag.isEnabled('new-checkout', userId)) {
+  return <NewCheckout />;
+} else {
+  return <OldCheckout />;
+}
+```
+## 🚨 RECOVERY MODE: "Bad deploy!"
+**EMERGENCY ROLLBACK:**
+```bash
+# Immediate rollback options
+# 1. Git revert
+git revert HEAD --no-edit
+git push origin main
+# 2. Platform rollback (Vercel)
+vercel rollback
+# 3. Container rollback (Docker)
+docker stop new_container
+docker start old_container
+# 4. Database rollback
+pg_restore -d database_name backup_file.dump
+# 5. DNS switch (if using blue-green)
+# Point DNS back to old environment
+# 6. Feature flag disable
+curl -X POST <https://api.launchdarkly.com/flags/broken-feature/off>
+```
+---
+# 🏆 QUICK REFERENCE TABLES
+## Success Metrics by Mode
+| Mode | Metric | Target |
+| --- | --- | --- |
+| **Speed** | Time to ship | < 4 hours |
+| **Discovery** | Clarity achieved | 3 prototypes tested |
+| **Production** | Uptime | 99.9% |
+| **Recovery** | Time to fix | < 30 minutes |
+## Technology Stack by Mode
+| Component | Speed Mode | Production Mode |
+| --- | --- | --- |
+| **Frontend** | React (single file) | Next.js/Remix |
+| **State** | useState | Zustand/Redux |
+| **Database** | localStorage | PostgreSQL |
+| **Auth** | None/hardcoded | Auth0/Clerk |
+| **Hosting** | Netlify/Vercel | AWS/Railway |
+| **Monitoring** | console.log | Sentry/DataDog |
+## When to Switch Modes
+| From → To | Trigger |
+| --- | --- |
+| **Speed → Discovery** | "I don't know what I'm building anymore" |
+| **Discovery → Speed** | "Now I know exactly what I want" |
+| **Speed → Production** | "Real users are depending on this" |
+| **Any → Recovery** | "Something is broken in production" |
+## Emergency Commands
+```bash
+# Git
+git log --oneline -10          # Find last working
+git checkout [hash] -- [file]  # Restore file
+git reset --hard [hash]        # Nuclear option
+# Database
+SELECT pg_terminate_backend(pid);  # Kill query
+VACUUM FULL table_name;            # Clean table
+REINDEX TABLE table_name;          # Fix index
+# Process
+pm2 restart all                # Restart apps
+kill -9 [PID]                  # Force kill
+systemctl restart nginx        # Restart nginx
+# Debug
+tail -f app.log               # Watch logs
+netstat -tulpn | grep :3000   # Check port
+df -h                         # Disk space
+top                           # CPU/Memory
+```
+---
+**Remember:** Choose your mode based on clarity and risk. Follow the technical patterns for your use case. Switch modes when the signals appear. Ship working code that helps users.