diff --git a/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/steps/step-01-init.md b/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/steps/step-01-init.md
index 22f4e2e0..5e8ec3d4 100644
--- a/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/steps/step-01-init.md
+++ b/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/steps/step-01-init.md
@@ -8,7 +8,7 @@ create_story_workflow: '{project-root}/_bmad/bmm/workflows/4-implementation/crea
 
 # File References
 thisStepFile: '{workflow_path}/steps/step-01-init.md'
-nextStepFile: '{workflow_path}/steps/step-02-pre-gap-analysis.md'
+nextStepFile: '{workflow_path}/steps/step-01b-load-playbooks.md'
 
 # Role
 role: null  # No agent role yet
diff --git a/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/steps/step-01b-load-playbooks.md b/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/steps/step-01b-load-playbooks.md
new file mode 100644
index 00000000..707df6ae
--- /dev/null
+++ b/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/steps/step-01b-load-playbooks.md
@@ -0,0 +1,297 @@
+# Step 1b: Load Applicable Playbooks (Automated Learning)
+
+**Goal:** Automatically load relevant playbooks and learnings before implementation starts
+
+---
+
+## What This Step Does
+
+Before writing any code, check if previous work has created playbooks/patterns that apply to this story. This creates a **positive feedback loop** where agents get smarter with each story.
+
+---
+
+## Execution
+
+### 1. Analyze Story for Keywords
+
+**Extract topics from story:**
+
+```bash
+story_file="{story_file}"
+
+# Extract keywords from:
+# - Story title
+# - Task descriptions
+# - Technical Requirements section
+# - Architecture Compliance section
+
+keywords=$(grep -E "^### Task|^## Technical|^## Architecture" "$story_file" | \
+  grep -oiE "(prisma|stripe|auth|cron|queue|state machine|billing|payment|migration|api|database|email|notification|cache|redis|s3)" | \
+  sort -u | tr '\n' ',' | sed 's/,$//')
+
+echo "📚 Story keywords: $keywords"
+```
+
+**Common keyword categories:**
+- **Technology:** Database ORM, payment processor, cache, storage, infrastructure
+- **Domain:** Business logic areas (determined by your project)
+- **Pattern:** Architecture patterns (state machine, cron, queue, api, etc.)
+
+### 2. Check for Existing Playbooks
+
+**Search playbook directory:**
+
+```bash
+playbook_dir="{project-root}/docs/playbooks"
+
+if [ ! -d "$playbook_dir" ]; then
+  echo "📚 No playbooks directory found - will create after implementation"
+  playbooks_loaded=0
+  skip_to_step_2=true
+fi
+
+# For each keyword, check if playbook exists
+applicable_playbooks=()
+
+for keyword in $(echo "$keywords" | tr ',' ' '); do
+  playbook_file="${playbook_dir}/${keyword}-playbook.md"
+
+  if [ -f "$playbook_file" ]; then
+    echo "✅ Found playbook: ${keyword}-playbook.md"
+    applicable_playbooks+=("$playbook_file")
+  fi
+done
+
+echo "📚 Applicable playbooks: ${#applicable_playbooks[@]}"
+```
+
+### 3. Load Playbooks (If Found)
+
+**For each applicable playbook:**
+
+```
+Read playbook file
+
+Extract sections:
+  - ## Best Practices
+  - ## Common Pitfalls
+  - ## Code Patterns
+  - ## Lessons Learned
+  - ## Do's and Don'ts
+
+Store in context for use during implementation
+```
+
+**Example:**
+
+```markdown
+📚 Loaded: {technology}-playbook.md
+
+Best Practices:
+- {Practice learned from previous implementations}
+- {Pattern that worked successfully}
+- {Standard established across stories}
+
+Common Pitfalls:
+- {Mistake that was made and fixed}
+- {Issue encountered and resolved}
+- {Edge case discovered}
+
+Code Patterns:
+- {Reusable pattern with code example}
+- {Configuration approach}
+- {Testing strategy}
+```
+
+### 4. Request Additional Context (If Needed)
+
+**If no playbooks found but keywords detected:**
+
+```
+🔍 No existing playbooks for: {keywords}
+
+Checking for project-level guidance...
+```
+
+**Use /get-playbook to request specific guidance:**
+
+```bash
+# For each keyword without playbook
+for keyword in $keywords_without_playbooks; do
+  echo "📖 Requesting playbook: $keyword"
+
+  # Invoke /get-playbook with keyword
+  # This searches docs/, pulls from project context, creates on-demand playbook
+
+  # If guidance found, cache for future use
+done
+```
+
+### 5. Display Loaded Context
+
+**Output to agent:**
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+📚 APPLICABLE LEARNINGS LOADED
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Story: {story_key}
+Keywords: {keywords}
+
+Playbooks Loaded: {count}
+1. prisma-playbook.md - Database schema best practices
+2. state-machine-playbook.md - State transition patterns
+3. billing-playbook.md - Payment processing learnings
+
+Key Guidance:
+✅ Use 2026 in migration names (not 2025)
+✅ Split enum add + use into 2 migrations
+✅ Test state transitions exhaustively
+✅ Idempotency keys for all charges
+✅ Never hardcode payment amounts
+
+These learnings come from previous story implementations.
+Use them to avoid repeating past mistakes.
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+---
+
+## Integration Points
+
+**This step runs:**
+- After Step 1 (Init) - story file loaded
+- Before Step 2 (Gap Analysis) - context ready
+- Before Step 3 (Write Tests) - patterns available
+- Before Step 4 (Implement) - guidance active
+
+**Feeds into:**
+- Step 2: Gap analysis sees playbook patterns
+- Step 3: Test patterns from playbooks
+- Step 4: Implementation follows playbook best practices
+- Step 7: Code review compares against playbook standards
+
+---
+
+## File Structure
+
+```
+docs/
+  playbooks/
+    prisma-playbook.md        # Prisma best practices
+    stripe-playbook.md        # Stripe integration patterns
+    auth-playbook.md          # Authentication learnings
+    state-machine-playbook.md # State machine patterns
+    cron-playbook.md          # Cron job patterns
+    billing-playbook.md       # Billing/payment learnings
+    migration-playbook.md     # Database migration rules
+```
+
+---
+
+## Playbook Template
+
+```markdown
+# {Technology/Domain} Playbook
+
+**Last Updated:** {date}
+**Source Stories:** {story-keys that contributed learnings}
+
+## Best Practices
+
+1. {Practice from successful implementations}
+2. {Pattern that worked well}
+3. {Standard we always follow}
+
+## Common Pitfalls
+
+❌ {Mistake that was made}
+✅ {How to avoid it}
+
+❌ {Another mistake}
+✅ {Correct approach}
+
+## Code Patterns
+
+**Pattern: {Name}**
+```typescript
+// Code example from actual implementation
+// Story: {story-key}
+```
+
+**When to use:** {Context}
+**When NOT to use:** {Anti-pattern}
+
+## Lessons Learned
+
+**Story {story-key}:**
+- Learned: {Insight}
+- Applied: {How we changed approach}
+- Result: {Outcome}
+
+## Do's and Don'ts
+
+**DO:**
+- {Positive practice}
+- {What works}
+
+**DON'T:**
+- {What to avoid}
+- {Anti-pattern}
+
+## References
+
+- Story implementations: {list of story-keys}
+- Architecture docs: {relevant docs}
+- External resources: {links}
+```
+
+---
+
+## Benefits
+
+**Positive Feedback Loop:**
+1. Story 18-1 implements Prisma migration → Learns "use 2026 in names"
+2. Story 18-1 complete → Extracts pattern → Saves to prisma-playbook.md
+3. Story 18-2 starts → Loads prisma-playbook.md → Applies learning
+4. Story 18-2 implements correctly first time (no year mistake)
+
+**Cumulative Intelligence:**
+- Epic 1: Creates foundational playbooks
+- Epic 2: Builds on Epic 1 playbooks, adds new learnings
+- Epic 18: Has 17 epics worth of learnings available
+- Gets smarter with every story
+
+**Prevents Repeated Mistakes:**
+- Migration year mistakes (happened multiple times)
+- Enum transaction limitations (PostgreSQL gotcha)
+- Story file naming inconsistencies (just experienced!)
+- Missing checkbox updates (just fixed!)
+
+---
+
+## Auto-Load Triggers
+
+**Automatic playbook loading based on story content:**
+
+| Story Contains | Auto-Load Playbooks |
+|----------------|---------------------|
+| Database ORM keywords | database-orm-playbook.md, migration-playbook.md |
+| Payment keywords | payment-playbook.md, billing-playbook.md |
+| Auth keywords | auth-playbook.md, security-playbook.md |
+| Scheduling keywords | cron-playbook.md, scheduling-playbook.md |
+| Queue/async keywords | queue-playbook.md, async-playbook.md |
+| State machine keywords | state-machine-playbook.md |
+| Email/notification keywords | email-playbook.md, notification-playbook.md |
+
+**Note:** Playbook names are derived from keywords found in your story files.
+The system adapts to your project's technology stack.
+
+---
+
+## Next Step
+
+When complete, continue to Step 2 (Pre-Gap Analysis) with loaded playbooks in context.
+
+**Next:** `{workflow_path}/steps/step-02-pre-gap-analysis.md`
diff --git a/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/steps/step-11-summary.md b/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/steps/step-11-summary.md
index 30860fed..15f09431 100644
--- a/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/steps/step-11-summary.md
+++ b/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/steps/step-11-summary.md
@@ -10,6 +10,8 @@ thisStepFile: '{workflow_path}/steps/step-11-summary.md'
 stateFile: '{state_file}'
 storyFile: '{story_file}'
 auditTrail: '{audit_trail}'
+nextStepFile: '{workflow_path}/steps/step-12-extract-learnings.md'
+
 
 # Role
 role: null
diff --git a/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/steps/step-12-extract-learnings.md b/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/steps/step-12-extract-learnings.md
new file mode 100644
index 00000000..47efce8d
--- /dev/null
+++ b/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/steps/step-12-extract-learnings.md
@@ -0,0 +1,406 @@
+# Step 12: Extract Learnings & Update Playbooks (Automated Feedback Loop)
+
+**Goal:** Extract patterns from completed implementation and save to playbooks for future stories
+
+---
+
+## What This Step Does
+
+After successful implementation, analyze what was built and extract:
+- Patterns that worked well
+- Mistakes that were made and fixed
+- Code examples worth reusing
+- Best practices discovered
+
+Save these to playbooks so future stories benefit from this learning.
+
+---
+
+## Execution
+
+### 1. Analyze Implementation
+
+**Review what was built:**
+
+```bash
+story_key="{story_key}"
+
+# Get commit for this story
+commit_hash=$(git log --oneline --grep="$story_key" -i | head -1 | cut -d' ' -f1)
+
+if [ -z "$commit_hash" ]; then
+  echo "⚠️ No commit found for $story_key - skipping learning extraction"
+  exit 0
+fi
+
+# Get files changed
+files_changed=$(git diff-tree --no-commit-id --name-only -r "$commit_hash")
+
+echo "📊 Analyzing implementation:"
+echo "  Story: $story_key"
+echo "  Commit: $commit_hash"
+echo "  Files: $(echo "$files_changed" | wc -l | tr -d ' ')"
+```
+
+### 2. Extract Applicable Keywords
+
+**From story file and code:**
+
+```bash
+# Extract from story title, tasks, and file paths
+keywords=$(cat "{story_file}" | \
+  grep -oiE "(prisma|stripe|auth|cron|queue|state.machine|billing|payment|migration|api|database|email|notification|terraform|sqs)" | \
+  sort -u)
+
+# Also extract from file paths
+tech_keywords=$(echo "$files_changed" | \
+  grep -oiE "(billing|payment|auth|email|queue|cron|migration)" | \
+  sort -u)
+
+all_keywords=$(echo -e "$keywords\n$tech_keywords" | sort -u | tr '\n' ',' | sed 's/,$//')
+
+echo "🔑 Keywords for playbook matching: $all_keywords"
+```
+
+### 3. Check Code Review Findings
+
+**If code review was executed, extract learnings:**
+
+```bash
+review_file="docs/sprint-artifacts/review-${story_key}.md"
+
+if [ -f "$review_file" ]; then
+  echo "📝 Code review exists - extracting learnings"
+
+  # Extract issues that were fixed
+  critical_issues=$(grep -A 3 "CRITICAL" "$review_file" || echo "none")
+  high_issues=$(grep -A 3 "HIGH" "$review_file" || echo "none")
+
+  # These become "Common Pitfalls" in playbooks
+fi
+```
+
+### 4. Identify Reusable Patterns
+
+**Parse code for patterns worth saving:**
+
+```bash
+# Look for:
+# - Well-structured functions (with JSDoc, error handling, tests)
+# - Reusable utilities
+# - Configuration patterns
+# - Test fixtures
+
+# Example patterns to extract:
+patterns_found=()
+
+# State machine pattern
+if echo "$files_changed" | grep -q "state.*machine"; then
+  patterns_found+=("state-machine")
+fi
+
+# Cron pattern
+if echo "$files_changed" | grep -q "cron"; then
+  patterns_found+=("cron-job")
+fi
+
+# Migration pattern
+if echo "$files_changed" | grep -q "migration"; then
+  patterns_found+=("database-migration")
+fi
+
+echo "🎯 Patterns identified: ${patterns_found[@]}"
+```
+
+### 5. Update or Create Playbooks
+
+**For each keyword/pattern:**
+
+```bash
+playbook_dir="{project-root}/docs/playbooks"
+mkdir -p "$playbook_dir"
+
+for keyword in $(echo "$all_keywords" | tr ',' ' '); do
+  playbook_file="${playbook_dir}/${keyword}-playbook.md"
+
+  if [ -f "$playbook_file" ]; then
+    echo "📖 Updating existing playbook: ${keyword}-playbook.md"
+    action="update"
+  else
+    echo "📝 Creating new playbook: ${keyword}-playbook.md"
+    action="create"
+  fi
+
+  # Extract learnings specific to this keyword
+  # Append to playbook
+done
+```
+
+### 6. Extract Specific Learnings
+
+**What to extract:**
+
+#### A. Best Practices (from successful implementation)
+
+```
+IF story completed with:
+  - All tests passing
+  - Code review found zero critical issues
+  - Clean implementation (no major refactors needed)
+
+THEN extract:
+  - Code patterns used
+  - File structure choices
+  - Testing approaches
+  - Configuration patterns
+```
+
+**Example extraction:**
+
+```markdown
+## Best Practices
+
+**Story {story-key} ({story-title}):**
+✅ {Successful pattern used}
+✅ {Approach that worked well}
+✅ {Quality standard met}
+✅ {Test coverage achieved}
+
+**Lesson:** {Key insight from implementation}
+**Pattern:** See {file-path}:{function-name}()
+```
+
+#### B. Common Pitfalls (from mistakes/fixes)
+
+```
+IF code review found issues, OR
+   Implementation required fixes, OR
+   Tests failed initially
+
+THEN extract:
+  - What went wrong
+  - How it was fixed
+  - How to avoid next time
+```
+
+**Example extraction:**
+
+```markdown
+## Common Pitfalls
+
+❌ **Story {story-key}: {Mistake description}**
+- Problem: {What went wrong}
+- Error: {Error message if applicable}
+- Root cause: {Why it happened}
+- Fix: {How it was resolved}
+- Prevention: {How to avoid in future}
+
+❌ **Story {story-key}: {Another mistake}**
+- Problem: {Issue encountered}
+- Fix: {Solution applied}
+- Prevention: {Best practice going forward}
+```
+
+#### C. Code Patterns (reusable snippets)
+
+```
+IF implementation created reusable code:
+  - Helper functions
+  - Type definitions
+  - Test utilities
+  - Configuration patterns
+
+THEN extract code snippets with documentation
+```
+
+**Example extraction:**
+
+```markdown
+## Code Patterns
+
+### Pattern: Idempotency Key Generation
+
+```typescript
+// Source: Story 18-1, lib/billing/billing-service.ts
+export function generateIdempotencyKey(
+  agreementId: string,
+  billingPeriod: string,
+  chargeType: ChargeType
+): string {
+  return `charge-${agreementId}-${billingPeriod}-${chargeType}`;
+}
+```
+
+**When to use:** Preventing duplicate charge creation
+**Why it works:** Deterministic key based on unique identifiers
+**Tests:** See __tests__/lib/billing/billing-service.test.ts:47
+```
+
+### 7. Commit Playbook Updates
+
+**If playbooks were created/updated:**
+
+```bash
+git add docs/playbooks/*.md
+
+git commit -m "docs: update playbooks from Story ${story_key} learnings
+
+Added/updated:
+$(git diff --cached --name-only docs/playbooks/ | sed 's/^/- /')
+
+Learnings from successful implementation of ${story_key}."
+```
+
+---
+
+## Output
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+✅ LEARNINGS EXTRACTED
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Playbooks Updated: {count}
+- prisma-playbook.md (added migration year validation)
+- state-machine-playbook.md (added transition validation pattern)
+- billing-playbook.md (added idempotency key pattern)
+
+Patterns Extracted: {count}
+- Idempotency key generation
+- State machine validation
+- Decimal field serialization
+
+Common Pitfalls Documented: {count}
+- Migration year sorting issue
+- Enum transaction limitation
+
+These learnings will benefit future stories!
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+---
+
+## Feedback Loop
+
+```
+Story N Implementation
+  ↓
+Extract Learnings (Step 12)
+  ↓
+Update Playbooks
+  ↓
+Commit Playbooks
+  ↓
+Story N+1 Starts
+  ↓
+Load Playbooks (Step 1b) ← Gets Story N's learnings!
+  ↓
+Implement with Knowledge
+  ↓
+Repeat
+```
+
+**Result:** Each story is smarter than the last.
+
+---
+
+## Skill Integration
+
+**Use existing /extract-patterns skill:**
+
+```bash
+# After implementation completes
+/extract-patterns story-key={story_key} output-dir=docs/playbooks/
+
+# This extracts:
+# - Code patterns
+# - Test patterns
+# - Configuration patterns
+# Saves to playbooks directory
+```
+
+**Use /get-playbook for on-demand guidance:**
+
+```bash
+# During Step 1b if no playbook exists
+/get-playbook topic=prisma-migrations
+
+# Searches project docs for guidance
+# Creates playbook if patterns found
+```
+
+**Use /get-more-context for comprehensive dives:**
+
+```bash
+# For complex stories (COMPLEX complexity level)
+/get-more-context topic=stripe-integration
+
+# Loads comprehensive documentation
+# More detailed than playbook
+# Used for high-stakes implementations
+```
+
+---
+
+## Configuration
+
+**In super-dev-pipeline/workflow.yaml:**
+
+```yaml
+learning_feedback:
+  enabled: true  # Enable automatic playbook loading/saving
+  playbook_dir: "{project-root}/docs/playbooks"
+
+  # When to extract learnings
+  extract_triggers:
+    - on_success: true  # Extract after successful completion
+    - on_code_review: true  # Extract from review findings
+    - on_complex: true  # Always extract from COMPLEX stories
+
+  # When to load playbooks
+  load_triggers:
+    - on_init: true  # Load at Step 1b
+    - keywords_required: 1  # Minimum keywords to trigger
+```
+
+---
+
+## Step Sequence Update
+
+**Before (without learning loop):**
+1. Init
+2. Gap Analysis
+3. Write Tests
+4. Implement
+...
+11. Summary
+
+**After (with learning loop):**
+1. Init
+**1b. Load Playbooks** ← NEW (loads previous learnings)
+2. Gap Analysis (informed by playbooks)
+3. Write Tests (uses test patterns from playbooks)
+4. Implement (follows playbook best practices)
+...
+11. Summary
+**12. Extract Learnings** ← NEW (saves for next story)
+
+---
+
+## Success Criteria
+
+**Step 1b succeeds when:**
+- [x] Keywords extracted from story
+- [x] Existing playbooks checked
+- [x] Applicable playbooks loaded (or noted as missing)
+- [x] Context ready for implementation
+
+**Step 12 succeeds when:**
+- [x] Learnings extracted from implementation
+- [x] Playbooks updated or created
+- [x] Patterns documented with code examples
+- [x] Playbooks committed to git
+
+---
+
+**Next:** Continue to Step 2 (Pre-Gap Analysis) with loaded playbook context.
diff --git a/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/workflow.yaml b/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/workflow.yaml
index 241c0fb9..936964fe 100644
--- a/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/workflow.yaml
+++ b/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/workflow.yaml
@@ -78,6 +78,56 @@ smart_batching:
   min_batch_size: 3 # Minimum tasks to form a batch
   fallback_on_failure: true # Revert to individual if batch fails
 
+# Automated learning feedback loop (NEW v1.6.0)
+learning_feedback:
+  enabled: true # Enable automatic playbook loading/saving
+  playbook_dir: "{project-root}/docs/playbooks"
+
+  # Step 1b: Load existing playbooks before implementation
+  load_playbooks:
+    enabled: true
+    step: "step-01b-load-playbooks.md"
+    triggers:
+      - keywords_detected: 1 # Load if any keywords found in story
+      - complex_story: true # Always load for COMPLEX stories
+
+  # Step 12: Extract learnings after implementation
+  extract_learnings:
+    enabled: true
+    step: "step-12-extract-learnings.md"
+    triggers:
+      - on_success: true # Extract after successful completion
+      - on_code_review: true # Extract from review findings
+      - on_complex: true # Always extract from COMPLEX stories
+      - skip_if_failed: true # Don't extract from failed implementations
+
+  # Keyword extraction
+  keywords:
+    auto_detect: true
+    sources:
+      - story_title
+      - task_descriptions
+      - file_paths
+      - technical_requirements
+    common_keywords:
+      - prisma
+      - stripe
+      - auth
+      - cron
+      - queue
+      - state machine
+      - billing
+      - payment
+      - migration
+      - api
+      - database
+      - email
+      - notification
+      - terraform
+      - sqs
+      - redis
+      - s3
+
   # Batchable pattern definitions
   batchable_patterns:
     - pattern: "package_installation"