Stop Repeating Yourself to Claude: Pro Workflow Builds Self-Correcting Memory

Stop Repeating Yourself to Claude: Pro Workflow Builds Self-Correcting Memory

You correct Claude the exact same way. Session after session. Week after week.

"Don't mock the database in tests." "Use camelCase for internal APIs." "Never commit .env files." You've said it fifty times. You will say it fifty-one. And every time Claude forgets, a little piece of your soul chips away.

Here's the dirty secret nobody told you about AI coding: context windows are graveyards. Everything you teach Claude today gets compacted into oblivion tomorrow. Your hard-won conventions? Vanished. That brilliant research rabbit hole you went down Tuesday? Gone by Friday. You're not building expertise—you're running on a hamster wheel of repetition.

But what if your AI assistant actually remembered? Not just surface-level prompt stuffing, but deep, searchable, compounding memory that gets smarter every single session?

Enter Pro Workflow—the open-source system that transforms Claude Code and Cursor from goldfish into elephants. Built by Rohit Ghumare, this isn't another dotfile dump or prompt collection. It's a production-grade knowledge plane with SQLite-backed persistence, FTS5 search, auto-research loops, and 34 battle-tested skills that make your AI coding workflows genuinely intelligent.

By session 50? You'll barely correct anything. Your research wikis will be denser than curated lists. And you'll wonder how you ever coded without it.

What Is Pro Workflow?

Pro Workflow is an open-source intelligence layer for AI coding agents—primarily Claude Code and Cursor—that solves the fundamental amnesia problem plaguing every AI-assisted developer.

Created by Rohit Ghumare and actively maintained with a thriving community, Pro Workflow sits underneath your AI sessions as a single SQLite store that captures, indexes, and retrieves everything worth remembering. Version 3.3 introduced the game-changing "knowledge plane"—persistent research wikis with FTS5 indexing, auto-research loops, and multi-LLM deliberation—on top of the existing self-correction memory system.

The project is exploding in popularity for good reason. While most developers are still copy-pasting CLAUDE.md files between projects, Pro Workflow users are building compound knowledge systems that appreciate in value. The repository boasts 34 skills, 8 specialized agents, 22 slash commands, and 37 hook scripts across 24 lifecycle events—making it one of the most sophisticated AI coding infrastructure projects available.

What makes it genuinely different? Everything persists. Every correction becomes a searchable rule. Every research session appends to a growing wiki. Every deliberation gets transcribed and indexed. You're not just coding faster—you're building an intellectual asset that outlives any single session.

The system works across 32+ AI coding agents via SkillKit integration, meaning your knowledge investment isn't locked to Claude Code alone. Cursor, Codex CLI, Gemini CLI, Windsurf, and dozens more can tap into the same memory store.

Key Features That Separate Amateurs from Pros

Pro Workflow isn't a collection of prompts—it's a systems architecture for AI-augmented development. Here's what makes it technically formidable:

Self-Correcting Memory with FTS5 Indexing

Every correction you make gets captured as a structured rule, stored in SQLite, and indexed with FTS5 full-text search. On session start, relevant learnings auto-load based on your project context. The learn-rule command now supports wiki scoping with Wiki: <slug> syntax, so corrections can target specific knowledge domains.

Persistent Knowledge Plane (v3.3)

Research wikis live on disk with 9 specialized flavors: research, paper, domain, product, person, organization, project, codebase, and incident. Each wiki gets path-traversal protection, FTS5 shadow indexing, and optional vector embeddings for hybrid retrieval. The auto-research loop performs budget-capped BFS (breadth-first search) across web, arXiv, and GitHub sources—with convergence detection and a kill switch.

Hybrid Retrieval (BM25 + Vector RRF)

For complex queries, Pro Workflow combines BM25 keyword search with vector similarity using Reciprocal Rank Fusion. Enable embeddings with OPENAI_API_KEY or VOYAGE_API_KEY, and watch your wikis surface relevant content through multiple semantic pathways.

Multi-LLM Council Deliberation

High-stakes decisions get provider-agnostic 3-phase deliberation across Anthropic, OpenAI, OpenRouter, Fireworks, or custom endpoints. Built with Promise.allSettled resilience—one provider failure won't abort your run. Transcripts persist as wiki pages for future reference.

24-Event Hook System

Thirty-seven scripts intercept lifecycle events: SessionStart loads learnings, UserPromptSubmit auto-injects top-3 wiki hits, Stop captures [LEARN] blocks, PreToolUse(Bash) validates commits, and PreCompact/PostCompact preserves critical state through context compaction.

Quality Gates and Observability

LLM-powered hooks (type: "prompt"), deterministic git/secret guards, compaction-aware state preservation, cost tracking with budget benchmarks, and MCP token-overhead auditing create multiple layers of verification before any destructive operation.

Real-World Scenarios Where Pro Workflow Dominates

Scenario 1: The Long-Term Codebase Maintainer

You're six months into a microservices architecture. You've explained service boundaries, retry policies, and observability conventions to Claude forty-three times. With Pro Workflow, each explanation becomes a learn-rule entry. By session 50, Claude proposes integration tests without prompting, cites your wiki on circuit breakers, and never again suggests mocking the database. Correction rate approaches zero.

Scenario 2: The Deep Researcher Building Expertise

You're investigating episodic memory in AI agents. Instead of scattered browser tabs and forgotten notes, you run /wiki init agent-memory --flavor research, seed it with "memory consolidation in agents," and let the auto-research loop run overnight with --budget-usd 0.50. By morning, your wiki has 200 cited claims, a bibliography-validated survey, and a link graph showing conceptual relationships. Your Tuesday research compounds into Thursday expertise.

Scenario 3: The Multi-Agent Team Lead

Your team uses Claude Code, Cursor, and Codex CLI across different services. Through SkillKit translation, Pro Workflow's 34 skills work identically across all agents. Shared wikis live in project-scope directories (<project>/.claude/wikis/) and get committed to git. Your team's knowledge becomes version-controlled infrastructure, not tribal lore trapped in individual heads.

Scenario 4: The High-Stakes Architect

You're deciding whether to adopt a new database pattern. Instead of trusting Claude's single opinion, you invoke /wiki council "should we adopt event sourcing?" and get multi-provider deliberation with dissenting viewpoints, confidence scores, and a persistent transcript. Three months later, when someone questions the decision, the full reasoning is searchable in your wiki.

Step-by-Step Installation & Setup Guide

Getting Pro Workflow running takes under five minutes. Choose your path:

Quick Install (Claude Code)

# Add to plugin marketplace
/plugin marketplace add rohitg00/pro-workflow

# Install the plugin
/plugin install pro-workflow@pro-workflow

Cursor Installation

/add-plugin pro-workflow

Universal Agent Install (SkillKit)

# Install via npx—works across 32+ agents
npx skillkit install pro-workflow

# Translate for your specific agent
npx skillkit translate pro-workflow --agent cursor
npx skillkit translate pro-workflow --agent codex
npx skillkit translate pro-workflow --agent gemini-cli

Manual Installation (Full Control)

# Clone to temporary location
git clone https://github.com/rohitg00/pro-workflow.git /tmp/pw

# Copy split-CLAUDE.md templates to your project
cp -r /tmp/pw/templates/split-claude-md/* ./.claude/

# Build SQLite-backed components
cd ~/.claude/plugins/*/pro-workflow && npm install && npm run build

Environment Configuration

Create your knowledge plane environment:

# Optional: Custom wiki storage location
export WIKI_ROOT=/path/to/your/wikis

# Required for hybrid retrieval (embeddings)
export OPENAI_API_KEY=sk-...        # or VOYAGE_API_KEY

# Multi-LLM council providers (first match wins)
export ANTHROPIC_API_KEY=sk-ant-...
export OPENROUTER_API_KEY=...
export FIREWORKS_API_KEY=...
# Or custom endpoint
export LLM_COUNCIL_BASE_URL=https://...
export LLM_COUNCIL_API_KEY=...

# Auto-research budget controls
export WIKI_LOOP_BUDGET_USD=0.50
export WIKI_LOOP_MAX_PAGES=5
export WIKI_LOOP_MAX_DEPTH=3

# GitHub fetcher rate limit lift
export GH_TOKEN=ghp_...             # or GITHUB_TOKEN

Verification

# Health check with full diagnostics
/doctor

# Should report: SQLite connected, FTS5 available, wiki KB ready, council providers responsive

REAL Code Examples from the Repository

Pro Workflow ships with immediately usable commands. Here are the actual patterns from the repository, explained in depth:

Example 1: The Self-Correction Loop

This is the core value proposition—capturing corrections so they compound:

# Session 1: You observe Claude making a mistake
# Instead of just fixing it, you capture it as a rule
/learn-rule          # Interactive: describe what went wrong and the correct pattern

# The rule gets stored in SQLite with FTS5 indexing
# Format: correction text + context + optional wiki scope
# Example input: "Don't mock the database in tests — use testcontainers instead. Wiki: backend-conventions"

# End session intentionally—this persists everything
/wrap-up             # Generates session summary, persists learnings, audits changes

What happens under the hood: The learn-rule skill writes to data.db in the learnings table, with optional learnings_wiki foreign key for scoping. On next SessionStart, the session-start.js hook queries: SELECT * FROM learnings WHERE wiki IS NULL OR wiki = ? ORDER BY created_at DESC LIMIT 50. Results get injected into context.

Example 2: Building a Research Wiki with Auto-Research

# Initialize a new research wiki
/wiki init agent-memory --title "Agent Memory" --flavor research
# Creates: ~/.pro-workflow/wikis/agent-memory/ with pages/, sources/, seeds/, derived/

# Add a concept page manually
/wiki page agent-memory wiki/concepts/episodic-memory.md --type concept
# Validates path (no traversal), adds to FTS5 index, links to sources.md

# Seed with a research topic—this is your starting point
/wiki seed agent-memory "memory consolidation in agents"
# Creates seed file, enqueues for verification

# Launch budget-capped auto-research (OPT-IN, controlled)
/wiki research agent-memory --max-pages 5 --budget-usd 0.50
# BFS over web/arXiv/GitHub fetchers
# Convergence detection stops when new claims diminish
# Atomic state: try/finally guards prevent corruption

# Emergency stop if needed
touch ~/.pro-workflow/STOP
# Any running loop checks this file between fetches and exits cleanly

The auto-research loop architecture: It's a state machine with budget guards. Each iteration: fetch source → extract claims → validate against existing → score novelty → decide continue/merge/stop. The --budget-usd flag creates a hard ceiling; --max-pages limits breadth. Claims get stored in wiki_claims with source_id foreign keys for traceability.

Example 3: Hybrid Retrieval Query

# First, generate embeddings for your wiki (one-time setup)
/wiki embed agent-memory
# Requires OPENAI_API_KEY or VOYAGE_API_KEY
# Stores vectors in wiki_embeddings table

# Query with hybrid BM25 + vector RRF
/wiki hybrid "consolidation patterns" --wiki agent-memory
# Returns: ranked results with BM25 scores, vector scores, fused ranking
# Auto-injected on UserPromptSubmit when prompts match indexed topics

Why hybrid matters: BM25 excels at exact terminology matches ("episodic memory"), while vector search catches semantic relatives ("experience replay in reinforcement learning"). Reciprocal Rank Fusion combines both without requiring training data—it's the same technique used by production search engines.

Example 4: Multi-LLM Council for High-Stakes Decisions

# Invoke provider-agnostic deliberation
/wiki council "should we adopt episodic memory?" --wiki agent-memory

# Behind the scenes:
# Phase 1: All providers generate independent analyses
# Phase 2: Cross-examination—each provider sees others' arguments
# Phase 3: Synthesis with confidence scores and dissent notes
# Promise.allSettled ensures partial failures don't kill the process

# Result: Transcript persists as wiki page
# Location: ~/.pro-workflow/council/<session-id>/<timestamp>.md
# Auto-linked from agent-memory wiki

Resilience pattern: The Promise.allSettled implementation is critical. If Anthropic rate-limits but OpenAI responds, you still get usable output with a note about the missing perspective. This beats Promise.all implementations that fail completely on any provider hiccup.

Example 5: Visual Wiki Browsing and Sharing

# Generate single-file HTML viewer
/wiki view agent-memory
# Creates: ~/.pro-workflow/wikis/agent-memory/derived/viewer.html

# Open locally
open ~/.pro-workflow/wikis/agent-memory/derived/viewer.html

# Or upload to S3 for team sharing
# Single file = zero dependencies, works offline
# Includes: pages, sources, seeds, link graph, in-browser search, "copy as seed" CTAs

The HTML-as-output philosophy: Inspired by Thariq Shihipar's thesis, this treats HTML as a knowledge artifact format—not just presentation. The viewer is inspectable, archivable, and future-proof in ways that SaaS dashboards aren't.

Advanced Usage & Best Practices

Start with /doctor before every major session. The extended diagnostics now cover wiki KB health and council provider responsiveness—catch configuration drift early.

Use wiki flavors intentionally. Don't dump everything into "research." A "codebase" wiki for architectural decisions, an "incident" wiki for post-mortems, and a "domain" wiki for business logic creates semantic boundaries that improve retrieval precision.

Set aggressive auto-research budgets. The default --budget-usd 0.50 and --max-pages 5 are conservative. For deep investigations, cap at $2.00 and 20 pages—but always set a ceiling. The kill switch (touch ~/.pro-workflow/STOP) is your emergency brake.

Leverage UserPromptSubmit auto-injection. The hook silently enriches your prompts with top-3 wiki hits when topics match. This means you don't even need to remember what you know—Pro Workflow surfaces it automatically.

Commit project-scope wikis to git. The <project>/.claude/wikis/ directory is designed for version control. Your team's knowledge evolves with your codebase, with full history and rollback capability.

Run /wrap-up religiously. The end-of-session ritual isn't bureaucracy—it's compounding infrastructure. Skipped sessions are lost compound interest.

Comparison with Alternatives

The verdict: ECC has raw volume (140+ skills), but Pro Workflow has systems depth—no competitor matches the SQLite persistence layer, auto-research infrastructure, or cross-agent portability. If you want a prompt library, use ECC. If you want compounding intelligence infrastructure, Pro Workflow is the only serious choice.

FAQ

Q: Does Pro Workflow work with Cursor, or only Claude Code? A: Both natively, plus 32+ agents via SkillKit. The /add-plugin pro-workflow command works in Cursor, and npx skillkit translate adapts skills for any supported agent.

Q: Where is my data stored? Is it private? A: Everything lives locally in SQLite at ~/.pro-workflow/data.db and flat files under ~/.pro-workflow/wikis/. No cloud service, no data exfiltration. Project-scope wikis can be committed to your private git repo.

Q: How much does the auto-research loop cost? A: Completely controllable. Default is $0.50 USD per run with --budget-usd. The BFS has convergence detection and stops early when novelty drops. The STOP file kills any loop instantly.

Q: Will this slow down my Claude Code sessions? A: FTS5 queries are sub-millisecond for typical learning sets. The SessionStart hook loads asynchronously. UserPromptSubmit injection triggers only when prompts match indexed topics—no overhead for unrelated work.

Q: Can I migrate my existing CLAUDE.md conventions? A: Yes. The templates/split-claude-md/ structure is designed for gradual migration. Import conventions as wiki pages, then capture corrections as they arise naturally.

Q: What happens if a wiki grows too large? A: The compaction-aware system (compact-guard skill) preserves critical state through context window pressure. For wikis, use --flavor scoping and periodic archival. The viewer HTML remains performant even with hundreds of pages.

Q: Is this production-ready for team use? A: Used daily by maintainers and growing teams. The MIT license permits commercial use. Project-scope wikis in git provide team synchronization. Start with /doctor and /auto-setup for validated configuration.

Conclusion

The future of AI coding isn't bigger context windows or smarter base models—it's persistent, compounding memory that turns ephemeral assistance into durable expertise.

Pro Workflow solves the fundamental broken promise of AI coding: that you'll never have to repeat yourself. With SQLite-backed self-correction, FTS5-indexed wikis, budget-capped auto-research, and multi-provider deliberation, it transforms Claude Code and Cursor from forgetful assistants into genuine intellectual partners that improve with every interaction.

After 50 sessions, the difference is stark. While others still explain their conventions for the fifty-first time, you'll be iterating on a knowledge base that researches itself overnight, cites its own sources, and rarely repeats old mistakes.

This is compound interest applied to developer productivity. And it's available now, open-source, with zero lock-in across 32+ agents.

👉 Star Pro Workflow on GitHub to track updates and support the project

📚 Read the full documentation for deep configuration guides

🛠️ Explore SkillKit to use Pro Workflow across your entire agent stack

The hamster wheel stops here. Install Pro Workflow today, run /learn-rule on your first correction, and start building intelligence that outlasts your sessions.