feat: add Vibe Coding pipeline for automated blog generation

Implement "Vibe Coding" plugin that transforms session memory files
into public-ready blog posts via CI/CD automation.

Features:
- New /vibe-init skill for one-command infrastructure setup
- Python blog generator using Anthropic API (Claude 3.5 Sonnet)
- GitHub Actions workflow triggered on .memory/ changes
- Automatic PR creation with generated drafts
- Comprehensive documentation and user guides

Architecture:
- Hybrid approach: Claude Code skill + CI/CD pipeline
- .github/scripts/blog_gen.py - Main generator (119 lines)
- .github/workflows/vibe_publisher.yml - GitHub Actions (56 lines)
- skills/vibe-init/skill.md - Plugin skill definition (275 lines)

Documentation:
- VIBE_CODING.md - Complete user guide (302 lines)
- IMPLEMENTATION_SUMMARY.md - Technical architecture (325 lines)
- VERIFICATION_CHECKLIST.md - QA verification report
- Updated CLAUDE.md, README.md, CLAUDE_TEMPLATE.md

Security:
- API keys loaded from environment variables only
- GitHub Secrets integration for CI/CD
- Pull request workflow for review before merge

Files created: 10 new files, 4 new directories, 1,077 lines of code
Cost: ~$0.03 per blog post using Claude 3.5 Sonnet

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: Oliver Baer

.github/scripts/blog_gen.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""
+Blog Generator for Vibe Coding Pipeline
+Converts .memory/*.md files into polished blog posts using Anthropic API
+"""
+
+import os
+import sys
+from pathlib import Path
+from datetime import datetime
+import anthropic
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+
+def get_latest_memory_file():
+    """Find the most recent letter file in .memory/"""
+    memory_dir = Path(os.path.abspath('.memory'))
+
+    if not memory_dir.exists():
+        print("❌ .memory/ directory not found")
+        sys.exit(1)
+
+    # Find all letter_*.md files
+    letter_files = sorted(memory_dir.glob('letter_*.md'), reverse=True)
+
+    if not letter_files:
+        print("❌ No letter files found in .memory/")
+        sys.exit(1)
+
+    return letter_files[0]
+
+
+def generate_blog_post(memory_content: str) -> str:
+    """Use Anthropic API to convert memory file to blog post"""
+    api_key = os.getenv('ANTHROPIC_API_KEY')
+
+    if not api_key:
+        print("❌ ANTHROPIC_API_KEY not found in environment")
+        sys.exit(1)
+
+    client = anthropic.Anthropic(api_key=api_key)
+
+    prompt = f"""You are a technical blog writer. Convert this development session memory into an engaging, public-ready blog post.
+
+INPUT (Session Memory):
+{memory_content}
+
+REQUIREMENTS:
+1. Transform technical decisions into narrative insights
+2. Keep the "Pain Log" as "Lessons Learned" or "Challenges"
+3. Make it readable for a general developer audience
+4. Add markdown frontmatter with: title, date, tags, excerpt
+5. Use proper markdown formatting with headers, code blocks, lists
+6. Maintain technical accuracy but improve readability
+
+OUTPUT FORMAT:
+---
+title: "[Engaging Title]"
+date: {datetime.now().strftime('%Y-%m-%d')}
+tags: [relevant, tags, here]
+excerpt: "Brief summary of the post"
+---
+
+[Blog post content in markdown]
+
+Generate the blog post now:"""
+
+    message = client.messages.create(
+        model="claude-3-5-sonnet-20241022",
+        max_tokens=4096,
+        messages=[
+            {"role": "user", "content": prompt}
+        ]
+    )
+
+    return message.content[0].text
+
+
+def save_blog_post(content: str, source_file: Path):
+    """Save generated blog post to drafts/"""
+    drafts_dir = Path(os.path.abspath('drafts'))
+    drafts_dir.mkdir(exist_ok=True)
+
+    # Generate filename based on source
+    timestamp = datetime.now().strftime('%Y-%m-%d')
+    output_file = drafts_dir / f"blog_{timestamp}_{source_file.stem}.md"
+
+    output_file.write_text(content, encoding='utf-8')
+    print(f"✅ Blog post generated: {output_file}")
+    return output_file
+
+
+def main():
+    """Main execution flow"""
+    print("🎨 Vibe Coding: Generating blog post...")
+
+    # Get latest memory file
+    memory_file = get_latest_memory_file()
+    print(f"📖 Reading: {memory_file}")
+
+    # Read content
+    memory_content = memory_file.read_text(encoding='utf-8')
+
+    # Generate blog post
+    print("🤖 Calling Anthropic API...")
+    blog_content = generate_blog_post(memory_content)
+
+    # Save to drafts
+    output_file = save_blog_post(blog_content, memory_file)
+
+    print(f"✅ Success! Blog post saved to: {output_file}")
+    print("🚀 Ready for review and publishing!")
+
+
+if __name__ == "__main__":
+    main()

.github/scripts/vibe_requirements.txt

@@ -0,0 +1,2 @@
+anthropic>=0.18.0
+python-dotenv>=1.0.0

.github/workflows/vibe_publisher.yml

@@ -0,0 +1,56 @@
+name: Vibe Publisher - Memory to Blog
+
+on:
+  push:
+    paths:
+      - '.memory/**'
+  workflow_dispatch:
+
+jobs:
+  generate-blog:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r .github/scripts/vibe_requirements.txt
+
+      - name: Generate blog post
+        env:
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+        run: |
+          python .github/scripts/blog_gen.py
+
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v6
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          commit-message: 'feat(blog): generate post from memory session'
+          title: '📝 New Blog Post from Session Memory'
+          body: |
+            ## 🎨 Vibe Coding Pipeline
+
+            Auto-generated blog post from latest session memory.
+
+            **Generated by:** Anthropic Claude API
+            **Source:** `.memory/` folder
+            **Output:** `drafts/` folder
+
+            ### Next Steps
+            - [ ] Review the generated content
+            - [ ] Edit for style/branding if needed
+            - [ ] Move to your blog publishing location
+            - [ ] Merge when ready
+          branch: blog-automation-${{ github.run_number }}
+          delete-branch: true

.memory/letter_example.md

@@ -0,0 +1,35 @@
+# Letter to Myself (Session Handoff)
+
+**Date:** 2026-01-29
+
+## 1. Executive Summary
+* **Goal:** Implement Vibe Coding pipeline to transform session memories into blog posts
+* **Current Status:** Successfully completed implementation with CI/CD integration
+
+## 2. The "Done" List (Context Anchor)
+* Created `skills/vibe-init/skill.md` - New skill for pipeline initialization
+* Implemented `.github/scripts/blog_gen.py` - Python script using Anthropic API
+* Created `.github/workflows/vibe_publisher.yml` - GitHub Actions workflow
+* Added `vibe_requirements.txt` with anthropic and python-dotenv dependencies
+* Updated CLAUDE.md with Vibe Coding documentation
+* Created comprehensive VIBE_CODING.md guide
+* Updated README.md and CLAUDE_TEMPLATE.md
+
+## 3. The "Pain" Log (CRITICAL)
+* **Tried:** Initial assumption was Python application with `src/` directory
+* **Failed:** Repository is actually a Claude Code plugin (markdown/YAML based)
+* **Workaround:** Adapted architecture to hybrid approach - Claude Code skill + CI/CD pipeline
+* *Note:* The correct architecture respects the existing plugin system while adding CI/CD automation
+
+## 4. Active Variable State
+* ANTHROPIC_API_KEY required in GitHub Secrets for automation
+* Default model: claude-3-5-sonnet-20241022
+* Output directory: `drafts/`
+* Trigger path: `.memory/**`
+
+## 5. Immediate Next Steps
+1. [x] Create all required files and directories
+2. [x] Verify Python syntax and structure
+3. [x] Update documentation (README, CLAUDE.md, VIBE_CODING.md)
+4. [ ] Test the pipeline with actual API key
+5. [ ] Create git commit with all changes

CLAUDE.md

@@ -0,0 +1,130 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+This is a Claude Code plugin called "Letter to Myself" that implements context persistence between Claude sessions. The plugin provides an agent and skill that automatically write structured "Last Will" summaries to a `.memory/` folder, enabling seamless continuity when sessions end, get compacted, or when days pass between work sessions.
+
+## Core Components
+
+### Plugin Structure
+- `.claude-plugin/plugin.json` - Plugin manifest defining name, version, and component paths
+- `agents/letter-for-my-future-self.md` - Agent persona that handles checkpoint creation
+- `skills/save-checkpoint/skill.md` - Skill that writes memory checkpoints to disk
+- `skills/vibe-init/skill.md` - Skill that sets up the Vibe Coding CI/CD pipeline
+- `CLAUDE_TEMPLATE.md` - Template users copy to their projects to enable the plugin
+- `install_agents.sh` - Installation script that sets up the plugin structure
+
+### Vibe Coding Pipeline (NEW)
+The plugin now includes a "Vibe Coding" feature that automatically transforms memory files into public-ready blog posts:
+- `.github/scripts/blog_gen.py` - Python script using Anthropic API for blog generation
+- `.github/scripts/vibe_requirements.txt` - Python dependencies (anthropic, python-dotenv)
+- `.github/workflows/vibe_publisher.yml` - GitHub Actions workflow triggered on .memory/ changes
+- `drafts/` - Output directory for generated blog posts
+
+### The Memory Protocol
+- Memory files are stored in `.memory/` as sequential markdown files (`letter_01.md`, `letter_02.md`, etc.)
+- Each file follows a strict template with sections: Executive Summary, Done List, Pain Log, Variable State, Next Steps
+- On startup, the agent reads the highest-numbered letter file to restore context
+- On checkpoint/exit, the agent generates a new letter with incremented number
+
+## Installation & Usage
+
+### Installing the Plugin
+```bash
+# Option A: Use the installation script (recommended)
+chmod +x install_agents.sh
+./install_agents.sh
+
+# Option B: Install as local plugin
+claude plugin install . --scope user
+```
+
+### Adding to a Project
+Copy `CLAUDE_TEMPLATE.md` into the target project as `CLAUDE.md` (or merge if one exists).
+
+### Triggering Checkpoints
+The agent activates when users type:
+- `/checkpoint`
+- `exit` or indicates session is ending
+- "wrap up"
+
+### Setting Up Vibe Coding
+Initialize the blog generation pipeline by running:
+```bash
+/vibe-init
+```
+
+This creates:
+1. Required directories (.memory/, drafts/, .github/scripts/, .github/workflows/)
+2. Blog generator script with Anthropic API integration
+3. GitHub Actions workflow for automatic blog post generation
+4. Python dependencies file
+
+**Required Setup:**
+Add `ANTHROPIC_API_KEY` to GitHub repository secrets (Settings → Secrets and variables → Actions)
+
+**How It Works:**
+1. Push changes to `.memory/*.md` files
+2. GitHub Actions automatically triggers
+3. Latest memory file is converted to blog post using Claude
+4. Pull request created with generated draft in `drafts/`
+5. Review and merge when ready
+
+## Memory Versioning
+
+See `MEMORY_VERSIONING.md` for comprehensive Git workflows:
+- **Option A**: Full versioning (recommended for solo projects)
+- **Option B**: Clean diffs with `.gitattributes` configuration
+- **Option C**: Team workflow with shared/private split
+- **Option D**: Security guardrails to prevent secrets in memory
+- **Option E**: Keep history clean with filtered logs or orphan branches
+- **Option F**: Archiving strategies for long-running projects
+
+Key commands for memory management:
+```bash
+# Commit memory after session
+git add .memory/shared
+git commit -m "chore(memory): session handoff"
+
+# Scan for secrets before committing
+rg -n --hidden --glob ".memory/**" -e "AKIA[0-9A-Z]{16}" -e "BEGIN( RSA)? PRIVATE KEY" .memory
+```
+
+## Architecture Notes
+
+### Plugin Design Philosophy
+- **Continuity over context**: Addresses the fundamental limitation of Claude's context window by creating persistent memory
+- **Minimal friction**: Automatic checkpoint creation on session end
+- **Structured format**: Strict template ensures consistent, actionable handoffs
+- **Pain Log emphasis**: Critical section for documenting failures and workarounds to prevent repeated mistakes
+
+### Agent Behavior
+The `letter-for-my-future-self` agent operates in two modes:
+1. **Normal mode**: Acts as a standard coding assistant
+2. **Checkpoint mode**: Triggered by exit signals, stops all work to review conversation history and generate a summary
+
+### Skill Execution
+The `save-checkpoint` skill:
+1. Creates `.memory/` directory if needed
+2. Lists existing letter files to determine next sequential number
+3. Writes the generated letter using the Write tool
+4. Confirms to user with filename
+
+## File Organization
+
+```
+.
+├── .claude-plugin/
+│   └── plugin.json           # Plugin manifest
+├── agents/
+│   └── letter-for-my-future-self.md  # Agent persona definition
+├── skills/
+│   └── save-checkpoint/
+│       └── skill.md          # Checkpoint skill definition
+├── CLAUDE_TEMPLATE.md        # Template for user projects
+├── install_agents.sh         # Installation script
+├── MEMORY_VERSIONING.md      # Git workflow guide
+├── QUICK_START.md           # User installation guide
+└── README.md                # Project documentation

CLAUDE_TEMPLATE.md

@@ -6,5 +6,14 @@ This project uses the **Letter to Myself** agent.
 1.  **Startup:** Always check the `.memory/` directory. Read the file with the highest number (e.g., `letter_05.md`) to understand the current state.
 2.  **Shutdown:** Before exiting or when asked to `/checkpoint`, use the `save-checkpoint` tool to write the next sequential letter.
 
+## 🎨 Vibe Coding (Optional)
+To enable automatic blog post generation from session memories:
+
+1.  **One-time setup:** Run `/vibe-init` to install the CI/CD pipeline
+2.  **Add API key:** Set `ANTHROPIC_API_KEY` in GitHub repository secrets
+3.  **Automatic:** Every push to `.memory/` triggers blog post generation
+
+See [VIBE_CODING.md](./VIBE_CODING.md) for complete documentation.
+
 ## 📝 Coding Standards
 (Add your normal coding standards here, e.g., TypeScript strict mode, Python PEP8, etc.)