noobygains Knowledge Capture
Overview
Every substantial interaction yields signal. A debugging session exposes a hidden codebase convention. A user correction reveals a preference. A failed plan uncovers a blind spot. Recording these observations is not overhead -- it is compound interest on capability.
Core principle: Solving a difficult problem without recording what you discovered means solving it from zero next time.
No exceptions. No workarounds. No shortcuts.
The Prime Directive
EXTRACT INSIGHT FROM EVERY MEANINGFUL INTERACTION
An interaction that ends without reflection is a wasted investment. You possessed the context, found the answer, observed what succeeded -- then discarded all of it.
No excuses:
- Do not skip capture because the task felt "routine"
- Do not skip capture because you are "about to switch contexts"
- Do not skip capture because the lesson seems "self-evident"
- What feels obvious with full context becomes invisible from a cold start
Reflect. Distill. Persist. Full stop.
When to Use
Mandatory after:
- Delivering a complex feature (which patterns proved effective?)
- Resolving a stubborn defect (what was the root-cause signature?)
- Receiving review feedback that surfaced issues (what should differ next time?)
- Being corrected by the user (new preference discovered)
- Revising a plan significantly (what was misjudged?)
- Discovering a codebase convention through trial and error (spare the next session that journey)
Exceptions (confirm with the human):
- One-line trivial fixes
- Interactions that produced no new information
- When the user explicitly declines
Tempted to think "there is nothing to capture here"? Pause. That is rationalization.
The Entry Protocol
AFTER completing any meaningful task:
1. REFLECT: What succeeded? What failed? What was unexpected?
2. DISTILL: What generalizable pattern or insight emerges?
3. DEDUPLICATE: Is this already recorded? Does it contradict something stored?
4. PERSIST: Write it to the appropriate memory file with date and context
5. PRUNE: Remove any prior entries that newer evidence invalidates
Omit any step = insight permanently lost
The Capture Lifecycle
digraph capture_lifecycle {
rankdir=TB;
node [shape=box style=filled];
task [label="Meaningful Task\nCompleted" fillcolor=lightyellow shape=doublecircle];
reflect [label="REFLECT\nWhat occurred?\nWhat surprised me?" fillcolor="#ccccff"];
distill [label="DISTILL\nAbstract the insight\nfrom the specifics" fillcolor="#ccccff"];
exists [label="Already\nrecorded?" shape=diamond fillcolor="#fff3e0"];
conflicts [label="Contradicts\nan existing entry?" shape=diamond fillcolor="#fff3e0"];
persist [label="PERSIST\nSave to memory\nwith date + context" fillcolor="#ccffcc"];
prune [label="PRUNE\nRemove outdated\nentry" fillcolor="#ffcccc"];
cluster [label="CLUSTER\n3+ related insights?\nForm a conviction" fillcolor="#ccffcc"];
promote [label="PROMOTE\nHigh-confidence conviction\n-> CLAUDE.md rule" fillcolor="#e8f5e9"];
skip [label="Skip\n(already known)" fillcolor="#eeeeee"];
task -> reflect;
reflect -> distill;
distill -> exists;
exists -> skip [label="yes, identical"];
exists -> conflicts [label="no"];
conflicts -> prune [label="yes"];
prune -> persist;
conflicts -> persist [label="no"];
persist -> cluster;
cluster -> promote [label="3+ confirmations"];
cluster -> task [label="await further\nevidence" style=dashed];
}
Categories of Insight
Effective Patterns
Code approaches, debugging tactics, and architectural choices that led to clean results. These are positive signals to reinforce.
Sample entry:
Date: 2025-04-10
Context: Built retry logic for third-party webhook delivery
Insight: Exponential backoff with random jitter eliminated thundering-herd spikes
Confidence: medium (validated once)
Failures and Their Remedies
What went wrong, how it was resolved, how to prevent recurrence. Failures yield the highest-signal lessons.
Sample entry:
Date: 2025-04-12
Context: Logging middleware silently swallowed request bodies after refactor
Insight: Any change to middleware ordering demands a full integration test pass -- blast radius is total
Confidence: high (validated by production incident)
User Preferences
Stylistic choices, tool preferences, and conventions the user follows. Discovered through corrections and direct statements.
Sample entry:
Date: 2025-04-13
Context: User corrected my naming approach
Insight: User requires camelCase for variables, PascalCase for types, and no abbreviations anywhere
Confidence: high (direct correction)
Project-Specific Knowledge
Architecture details, hidden gotchas, critical files, tribal knowledge that lives nowhere in documentation.
Sample entry:
Date: 2025-04-14
Context: Spent 15 minutes searching for runtime config
Insight: All runtime configuration lives in src/config/runtime.ts, not in .env files
Confidence: high (verified in source)
Storage Mechanism
Leverage Claude Code's memory system: ~/.claude/projects/[project]/memory/
Memory File Taxonomy
| File | Purpose | Example Entry |
|---|---|---|
effective-patterns.md |
Code approaches and strategies that produced clean outcomes | "Zod schemas at API boundaries catch malformed data before it propagates" |
failure-analysis.md |
Root-cause patterns and diagnostic techniques | "Tests passing locally but failing in CI usually indicate timezone or locale assumptions" |
project-map.md |
Architecture, key files, and codebase conventions | "Database migrations reside in db/migrations/ and execute via pnpm db:migrate" |
human-preferences.md |
Stylistic choices, tooling preferences, and conventions the user enforces | "User demands explicit error types; string-based errors are rejected" |
Entry Structure
Every captured insight must include:
### [Concise title]
- **Date:** YYYY-MM-DD
- **Context:** What was happening when this was discovered
- **Insight:** The generalized takeaway
- **Confidence:** low / medium / high
- **Confirmations:** Number of times this has been validated
Deduplication Protocol
Before writing a new entry, scan the target memory file. If the insight already exists:
- Same insight, same confidence level -> skip entirely
- Same insight, elevated confidence -> update confidence and increment confirmation count
- Contradicting insight -> replace the old entry, note the contradiction
The Maturation Cycle
Isolated insights become powerful when they converge into convictions.
From Insight to Conviction
Insight 1: "This project validates forms with zod" (medium confidence)
Insight 2: "API route handlers also validate payloads with zod" (medium confidence)
Insight 3: "User corrected me for using manual validation instead of zod" (high confidence)
Converge into conviction
Conviction: "This project ALWAYS validates at every boundary using zod"
Confidence: high (confirmed across 3 interactions)
From Conviction to Rule
When a conviction reaches high confidence (confirmed across 3+ interactions), it becomes eligible for promotion to a project CLAUDE.md rule:
Conviction: "This project always validates with zod"
-> Confirmed 3+ times
-> Propose to user: "I have observed that this project consistently
uses zod for validation. Should I codify this as a project rule in CLAUDE.md?"
-> User approves -> add to CLAUDE.md
Never auto-promote. Always obtain user consent before adding entries to CLAUDE.md. The human is the final authority on permanent rules.
Session-Start Review
When beginning a new session on a project:
- Read all memory files for the project
- Identify clusters of related insights that have not been synthesized
- Flag entries that may be stale (old date, low confidence, never reconfirmed)
- Surface convictions ready for promotion
Confidence Tiers
| Tier | Meaning | Origin | Action |
|---|---|---|---|
| Low | Tentative signal | Single occurrence, unconfirmed | Record, watch for confirmation |
| Medium | Probable pattern | Confirmed twice, or one strong indicator | Record, apply when relevant |
| High | Established truth | Confirmed 3+ times, or explicit user declaration | Record, apply consistently, consider promotion |
Cognitive Traps
| Rationalization | Truth |
|---|---|
| "There is nothing to capture here" | Every task produces signal. You are not examining closely enough. |
| "I will recall this naturally" | You will not. The next session starts with a blank slate. Memory files are your continuity. |
| "Too minor to bother recording" | Minor insights accumulate. Three small observations become one powerful conviction. |
| "It is self-evident" | Self-evident to you now, with full context. Not self-evident when cold-starting next week. |
| "Recording takes too long" | Thirty seconds to write an entry. Thirty minutes to rediscover the same insight. |
| "The user did not request this" | They requested quality. Learning from experience IS how quality improves over time. |
| "Memory files are getting cluttered" | That is a pruning problem, not a recording problem. Prune more; never stop capturing. |
| "This only applies to this one project" | Project-specific knowledge is the MOST valuable kind. That is precisely why it is stored per-project. |
Guardrails
Prohibited actions:
- Skipping reflection after a difficult debugging session
- Storing entries without date and context (undated insights decay)
- Auto-adding rules to CLAUDE.md without user approval
- Recording the same insight twice without deduplication
- Retaining entries that newer evidence contradicts
- Recording implementation minutiae instead of generalizable patterns
Required actions:
- Reflect after completing any significant work
- Check memory before persisting (deduplicate)
- Attach confidence levels to every entry
- Obtain user consent before promoting convictions to CLAUDE.md rules
- Prune entries invalidated by newer evidence
- Organize entries by topic, not chronologically
Integration
This skill feeds INTO other skills:
- godmode:fault-diagnosis -- Historical failure analysis informs current troubleshooting
- godmode:pattern-matching -- Captured conventions reinforce code conformity
- godmode:test-first -- Past test failures shape future test strategy
- godmode:task-planning -- Past plan failures prevent repeating misjudgments
- godmode:quality-enforcement -- Captured quality patterns elevate the baseline
This skill is fed BY other skills:
- godmode:review-response -- Review feedback becomes captured insights
- godmode:completion-gate -- Verification failures become recorded lessons
- godmode:comprehension-check -- Walkthrough findings become stored observations
- godmode:task-runner -- Plan execution reveals what works and what does not
The virtuous cycle:
Work -> Capture -> Persist -> Apply -> Work better -> Capture more