jettypod 3.0.1

package/docs/core-jettypod-methodology/deprecated/vibe-coding-cheatsheet (1).md

@@ -0,0 +1,516 @@
+# The Vibe Coding Operating System: Complete Implementation Cheatsheet
+
+## Core Formula: CLARITY + RISK = MODE
+
+```
+Low Clarity  + Low Risk  = Discovery Mode
+High Clarity + Low Risk  = Speed Mode  
+High Clarity + Low/Med Risk = Stable Mode (NEW)
+High Clarity + High Risk = Production Mode
+Low Clarity  + High Risk = STOP (Discovery first)
+```
+
+## The Modes & Their Purpose
+
+| Mode | Goal | Time to Ship | Test Count | When to Use |
+|------|------|--------------|------------|-------------|
+| **Discovery** | Find what to build | Never (prototypes only) | 0-3 per prototype | Multiple viable approaches unclear |
+| **Speed** | Validate it works | 2-4 hours | 3-5 BDD scenarios | Know what to build, need it to exist |
+| **Stable** | Make it dependable | 1-2 days | 10-15 BDD + unit tests | Others will depend on it |
+| **Production** | Make it bulletproof | 1-2 weeks | 30+ BDD + full coverage | Public use, sensitive data, money |
+
+## Altitude Rules (Hierarchical Constraints)
+
+```
+Project Mode = Ceiling for everything
+├── Feature Mode ≤ Project Mode  
+└── Task Mode ≤ Feature Mode
+```
+
+**Examples:**
+- Project in Speed → Features can be Discovery or Speed (NEVER Production/Stable)
+- Project in Production → Features can be any mode
+- Feature in Speed → Tasks can only be Discovery or Speed
+
+## Mode Transition Triggers
+
+### Forward Transitions
+- **Discovery → Speed:** "I know exactly what to build now" + can write 3-5 clear scenarios
+- **Speed → Stable:** "Other features will depend on this" OR "10+ daily users"
+- **Stable → Production:** "Going public" OR "Handling sensitive data" OR "100+ users"
+
+### Emergency Transition
+- **Any → Recovery:** Something is broken in production → FIX FIRST
+
+### Dependency Rule
+**Before Feature B depends on Feature A:** Either elevate A to Stable OR create isolation interface
+
+## Test Architecture by Mode
+
+### Discovery Mode Tests
+```gherkin
+# 0-3 scenarios per prototype
+Scenario: Does approach X solve the problem?
+  Given the user problem
+  When using approach X
+  Then evaluate if this helps
+```
+
+### Speed Mode Tests (3-5 scenarios)
+```gherkin
+Feature: Core Value Delivery
+
+Scenario: Primary happy path
+  Given user has [problem]
+  When they use core feature
+  Then [problem] is solved
+
+Scenario: Data persists
+  Given work completed
+  When app restarts
+  Then work still there
+
+# Just prove it works
+```
+
+### Stable Mode Tests (10-15 scenarios)
+```gherkin
+Feature: Dependable Behavior
+
+# All Speed tests PLUS:
+
+Scenario: Handles missing data
+  Given incomplete input
+  When action attempted
+  Then meaningful error
+  And system stays stable
+
+Scenario: State integrity maintained  
+  Given concurrent modifications
+  When conflicts occur
+  Then resolved predictably
+
+# Prove it won't surprise dependencies
+```
+
+### Production Mode Tests (30+ scenarios)
+```gherkin
+Feature: Bulletproof System
+
+# All Stable tests PLUS:
+
+Scenario Outline: Security validation
+  Given malicious <input>
+  When processed
+  Then attack prevented
+  
+Scenario: Load handling
+  Given 100 concurrent users
+  When all act simultaneously  
+  Then response < 200ms
+  And no data corruption
+
+# Prove nothing bad can happen
+```
+
+## Integration Test Requirements
+
+**Every Mode Needs:**
+```gherkin
+Scenario: Features work together
+  Given Feature A creates data
+  When Feature B uses that data
+  Then data flows correctly
+  And state is consistent
+```
+
+**Anti-Pattern Prevention:** Claude builds isolated features by default
+- Always include "must integrate with [existing feature]" in prompts
+- Write integration test BEFORE building feature
+- Include current state structure in context
+
+## Technical Stack by Mode
+
+| Component | Discovery | Speed | Stable | Production |
+|-----------|-----------|--------|---------|------------|
+| **Frontend** | HTML + CDN | Single React file | React components | Next.js/Remix |
+| **State** | Local variables | useState | Context/Zustand | Redux/Zustand + persistence |
+| **Data** | Hard-coded | localStorage | IndexedDB/SQLite | PostgreSQL |
+| **Auth** | None | None | Basic auth | Auth0/Clerk |
+| **Hosting** | Local only | Netlify drop | Netlify/Vercel | AWS/Railway |
+| **Errors** | console.log | Try/catch basics | Error boundaries | Sentry + monitoring |
+| **Backup** | None | None | Export function | Automated backups |
+
+## Code Evolution Patterns
+
+### Speed Mode Code
+```javascript
+// Just works
+const saveData = (data) => {
+  localStorage.setItem('data', JSON.stringify(data))
+}
+```
+
+### Stable Mode Evolution
+```javascript
+// Same feature, hardened
+const saveData = (data) => {
+  try {
+    if (!data) throw new Error('No data to save')
+    const serialized = JSON.stringify(data)
+    if (serialized.length > 5000000) {
+      throw new Error('Data too large')
+    }
+    localStorage.setItem('data', serialized)
+    return { success: true }
+  } catch (error) {
+    console.error('Save failed:', error)
+    showUserError('Could not save changes')
+    return { success: false, error: error.message }
+  }
+}
+```
+
+### Production Mode Evolution
+```javascript
+// Bulletproof with monitoring
+const saveData = async (data) => {
+  const transaction = await db.transaction()
+  try {
+    validateData(data) // Throws if invalid
+    await transaction.data.upsert(data)
+    await transaction.commit()
+    await auditLog('data_saved', { userId, dataId: data.id })
+    metrics.increment('data.saves.success')
+    return { success: true }
+  } catch (error) {
+    await transaction.rollback()
+    logger.error('Save failed', { error, userId, data })
+    metrics.increment('data.saves.failure')
+    Sentry.captureException(error)
+    throw new UserFacingError('Could not save changes. Support notified.')
+  }
+}
+```
+
+## File Organization by Mode
+
+### Speed Mode
+```
+/src
+  app.js        # Everything in one file
+  app.test.js   # 3-5 tests
+```
+
+### Stable Mode
+```
+/src
+  /components   # Extracted components
+  /utils        # Shared utilities
+  /tests        # Organized tests
+  app.js        # Main entry
+```
+
+### Production Mode
+```
+/features
+  /expenses
+    index.js    # Public API
+    components/ # Feature components
+    utils/      # Feature utilities
+    tests/      # Feature tests
+    types.ts    # TypeScript types
+```
+
+## Claude Prompting by Mode
+
+### Discovery Mode Prompt
+```
+"Show me 3 different approaches to [problem]:
+1. Simplest possible
+2. More sophisticated  
+3. Most complete
+Build working prototypes I can try."
+```
+
+### Speed Mode Prompt
+```
+"Build [feature] that passes these scenarios:
+[3-5 Gherkin scenarios]
+- Single file
+- localStorage for data
+- Ship in 2 hours
+- Skip edge cases"
+```
+
+### Stable Mode Prompt
+```
+"Enhance [feature] for reliability:
+Current code: [paste]
+Current tests: [paste]
+Make it dependable for other features to use:
+- Add error handling
+- Validate inputs
+- Stable interface
+- Keep all existing tests passing"
+```
+
+### Production Mode Prompt
+```
+"Production-grade implementation:
+[Comprehensive Gherkin scenarios]
+Requirements:
+- Full error handling
+- Security validation
+- Transaction safety
+- Monitoring hooks
+- Performance optimization
+Include tests for all edge cases."
+```
+
+## Daily Workflow Checklist
+
+### Starting a Session
+1. **Check Project Mode** (sets ceiling)
+2. **Check Feature Mode** (within project constraints)
+3. **Write test scenarios FIRST** (BDD)
+4. **Include integration requirements** 
+5. **Prompt with appropriate mode context**
+
+### Before Committing
+- [ ] Tests pass
+- [ ] Integration tests pass
+- [ ] No orphan files
+- [ ] Code matches current mode standards
+
+### Mode Transition Checklist
+- [ ] Current tests all passing
+- [ ] Write new mode's tests (they should fail)
+- [ ] Upgrade code to pass new tests
+- [ ] Update integration tests
+- [ ] Clean up obsolete code
+
+## Cleanup Schedule
+
+| Mode | When to Clean | What to Clean |
+|------|---------------|---------------|
+| Discovery | Never | Nothing - will be deleted |
+| Speed | Never | Nothing - accept the mess |
+| Stable | During transition | Unused files, duplicate utils, organize by feature |
+| Production | Weekly | Dead code, optimize imports, document patterns |
+
+## The Dependency Decision Tree
+
+```
+Will something depend on this feature?
+├─ No → Keep in Speed Mode
+└─ Yes → Will it be critical to dependencies?
+    ├─ No → Stable Mode (hardened but simple)
+    └─ Yes → Production Mode (full safety)
+```
+
+## Recovery Mode Protocol
+
+1. **Stop the bleeding** (disable feature/rollback)
+2. **Communicate** (notify affected users)
+3. **Write failing test** (reproduce bug)
+4. **Fix with minimal change** (no refactoring)
+5. **Verify all tests pass**
+6. **Add regression tests**
+7. **Check for similar bugs**
+8. **Write postmortem**
+9. **Return to previous mode**
+
+## Anti-Patterns to Avoid
+
+### Discovery Mode
+❌ Writing documentation  
+❌ Setting up CI/CD  
+❌ Choosing architecture
+
+### Speed Mode  
+❌ Custom auth  
+❌ Microservices  
+❌ >5 test scenarios  
+❌ Refactoring  
+
+### Stable Mode
+❌ Premature optimization  
+❌ Complex monitoring  
+❌ Compliance features  
+
+### Production Mode
+❌ Shipping untested  
+❌ No error handling  
+❌ Skipping security  
+❌ No rollback plan  
+
+## Success Metrics
+
+| Mode | Success Looks Like | Failure Looks Like |
+|------|-------------------|-------------------|
+| Discovery | Clear direction found | Built nothing / Analysis paralysis |
+| Speed | Shipped in <4 hours, users trying it | Took days, over-engineered |
+| Stable | Dependencies work smoothly | Cascading failures through features |
+| Production | 99.9% uptime, no data loss | Security breaches, data corruption |
+
+## The Golden Rules
+
+1. **Tests are truth** - Documentation lies, tests run
+2. **Mode sets standards** - Don't apply Production patterns in Speed Mode
+3. **Integration is mandatory** - Isolated features are broken features
+4. **Elevation is additive** - Never delete tests, only add
+5. **Dependencies force elevation** - Stable minimum for anything others depend on
+6. **Ship beats perfect** - Speed Mode today beats Production Mode never
+
+## Quick Reference: File Cleanup Patterns
+
+### The Speed Mode Mess (Accept It)
+```
+/src
+  ExpenseList.js      ✓ Keep (it works)
+  ExpenseListNew.js   ✓ Keep (might need later)
+  ExpenseList2.js     ✓ Keep (who knows?)
+  helpers.js          ✓ Keep (something uses it)
+```
+
+### The Stable Mode Cleanup (During Transition)
+```bash
+# Step 1: Find orphans
+grep -r "ExpenseListNew" .  # Not found? Delete it
+
+# Step 2: Consolidate
+cat expense*.js > temp.js   # See the duplication
+# Extract shared logic to utils
+
+# Step 3: Test
+npm test  # Still passes? Cleanup succeeded
+```
+
+### The Production Mode Organization
+```
+/features/expenses/
+  index.js           # Public exports only
+  ExpenseList.js     # Single source of truth
+  utils.js           # Consolidated helpers
+  tests/             # All expense tests
+```
+
+## Mode-Specific Testing Commands
+
+```bash
+# Discovery Mode
+# No automated tests - just manual testing
+
+# Speed Mode  
+npm test -- --maxWorkers=1  # 3-5 tests, should be instant
+
+# Stable Mode
+npm test -- --coverage       # Ensure critical paths covered
+npm run test:integration     # Features work together
+
+# Production Mode  
+npm test -- --coverage --watchAll=false  # Full suite
+npm run test:e2e             # End-to-end scenarios
+npm run test:load            # Performance testing
+npm run test:security        # Security scanning
+```
+
+## The Elevation Pattern in Practice
+
+### Week 1: Speed Mode (Working)
+```javascript
+function addExpense(amount) {
+  expenses.push(amount)
+  updateTotal()
+}
+```
+
+### Week 2: Stable Mode (Dependable)
+```javascript
+function addExpense(amount) {
+  if (!isValidAmount(amount)) {
+    throw new Error('Invalid amount')
+  }
+  
+  try {
+    expenses.push(amount)
+    updateTotal()
+    persistData()
+  } catch (error) {
+    console.error('Failed to add expense', error)
+    showUserError('Could not add expense')
+  }
+}
+```
+
+### Week 3: Production Mode (Bulletproof)
+```javascript
+async function addExpense(amount, userId, metadata) {
+  // Validation
+  const validated = await validateExpense(amount, userId)
+  
+  // Transaction
+  const transaction = await db.transaction()
+  
+  try {
+    // Business logic
+    const expense = await transaction.expenses.create({
+      amount: validated.amount,
+      userId,
+      metadata,
+      createdAt: new Date()
+    })
+    
+    // Update aggregates
+    await transaction.userTotals.increment(userId, amount)
+    
+    // Commit
+    await transaction.commit()
+    
+    // Side effects
+    await auditLog('expense.created', { expenseId: expense.id, userId })
+    metrics.increment('expenses.created')
+    
+    return { success: true, expense }
+    
+  } catch (error) {
+    await transaction.rollback()
+    logger.error('Failed to add expense', { error, userId, amount })
+    Sentry.captureException(error)
+    
+    throw new UserFacingError('Could not add expense. Support has been notified.')
+  }
+}
+```
+
+## Integration Test Template
+
+```gherkin
+# EVERY feature needs this test
+Feature: [New Feature] Integration
+
+Scenario: Integrates with existing features
+  Given the current system state
+  When [new feature] is used
+  Then it reads existing data correctly
+  And it writes data other features can use
+  And it respects existing state management
+  And it appears in the main UI
+  And existing features still work
+```
+
+## The Mode Decision Matrix
+
+| Question | Discovery | Speed | Stable | Production |
+|----------|-----------|-------|---------|------------|
+| How many users? | 0 (just me testing) | 1-10 | 10-100 | 100+ |
+| Data loss impact? | Don't care | Annoying | Painful | Catastrophic |
+| Development time? | Unlimited | 2-4 hours | 1-2 days | 1-2 weeks |
+| Test coverage? | None | Happy path | Edge cases | Everything |
+| Refactor tolerance? | Change everything | Change freely | Change carefully | Change never |
+| Deploy confidence? | YOLO | Probably fine | Should work | Will work |
+
+---
+
+*Remember: The mode you choose determines the standards you apply. Don't bring Production Mode thinking to Speed Mode problems, and don't bring Speed Mode standards to Production Mode systems.*