Agent skill

Knowledge Capture

by NoobyGains in NoobyGains/godmode

A skill your agent uses when completing any meaningful task - distill patterns, lessons, and insights from the interaction and persist them for future sessions

MITAuto-check: notes

Install Knowledge Capture

skills CLI
$ npx skills add NoobyGains/godmode --skill knowledge-capture -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install NoobyGains/godmode knowledge-capture --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/NoobyGains/godmode.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/knowledge-capture .claude/skills/knowledge-capture && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
knowledge-capture
GitHub stars
107
Token cost
~2.8k tokens
SKILL.md length
922 words
Files
1
Skills in repo
34
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when completing any meaningful task - distill patterns, lessons, and insights from the interaction and persist them for future sessions

  • Works in 4 steps: Read all memory files for the project → Identify clusters of related insights… → Flag entries that may be stale (old… → …
  • Completing any meaningful task - distill patterns
  • SKILL.md covers Overview, The Prime Directive, When to Use and The Entry Protocol, plus 8 more sections
  • Calls pnpm

What it does

Knowledge Capture is an agent skill from NoobyGains/godmode. Use when completing any meaningful task - distill patterns, lessons, and insights from the interaction and persist them for future sessions

Its SKILL.md is about 2.8k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

The repository describes itself as: The AI development framework that thinks before it builds. 36 composable skills for Claude Code, Cursor, Codex, and OpenCode. The licence is MIT.

When your agent uses it

  • Completing any meaningful task - distill patterns
  • Insights from the interaction and persist them for future sessions

Example prompts

  • “/knowledge-capture”

Workflow steps

4 steps, taken from the first numbered list in SKILL.md.

  1. Read all memory files for the project
  2. Identify clusters of related insights that have not been synthesized
  3. Flag entries that may be stale (old date, low confidence, never reconfirmed)
  4. Surface convictions ready for promotion

What it can do on your machine

Read from SKILL.md and the folder at commit 441103a. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • pnpm

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use pnpm, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Knowledge Capture loads about 2.8k tokens when it runs. Until then it costs about 39 tokens; SKILL.md has 922 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~39
When it runs · the whole SKILL.md, loaded when a task matches
~2.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NoteMentions a .env fileSKILL.md:142
    n lives in src/config/runtime.ts, not in .env files

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from NoobyGains/godmode at commit 441103a, republished under its MIT licence (© NoobyGains). 922 words, ~2,840 tokens.

Download SKILL.mdSave it as .claude/skills/knowledge-capture/SKILL.md (or your agent's skills folder).
name
knowledge-capture
description
Use when completing any meaningful task - distill patterns, lessons, and insights from the interaction and persist them for future sessions

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

dot
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
FilePurposeExample Entry
effective-patterns.mdCode approaches and strategies that produced clean outcomes"Zod schemas at API boundaries catch malformed data before it propagates"
failure-analysis.mdRoot-cause patterns and diagnostic techniques"Tests passing locally but failing in CI usually indicate timezone or locale assumptions"
project-map.mdArchitecture, key files, and codebase conventions"Database migrations reside in db/migrations/ and execute via pnpm db:migrate"
human-preferences.mdStylistic 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:

markdown
### [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:

  1. Read all memory files for the project
  2. Identify clusters of related insights that have not been synthesized
  3. Flag entries that may be stale (old date, low confidence, never reconfirmed)
  4. Surface convictions ready for promotion
Show full SKILL.md (358 more words)Show less

Confidence Tiers

TierMeaningOriginAction
LowTentative signalSingle occurrence, unconfirmedRecord, watch for confirmation
MediumProbable patternConfirmed twice, or one strong indicatorRecord, apply when relevant
HighEstablished truthConfirmed 3+ times, or explicit user declarationRecord, apply consistently, consider promotion

Cognitive Traps

RationalizationTruth
"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

© NoobyGains, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/knowledge-capture of NoobyGains/godmode.

Open the folder on GitHubat commit 441103a

Compare with similar skills

Knowledge Capture next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Knowledge Capture compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Knowledge Capture this skillNoobyGains/godmode107—~2.8kAutomated safety check: NotesMIT
Capturealirezarezvani/claude-skills28k1 repos~2.8kAutomated safety check: PassMIT
Lesson Memory Recorderrohitg00/agentmemory29k—~721Automated safety check: PassApache-2.0
Paperclip Distillpaperclipai/paperclip98k—~2.8kAutomated safety check: PassMIT
Rules Distillationaffaan-m/ECC274k2 repos~2.3kAutomated safety check: PassMIT
Taste Distillationaffaan-m/ECC274k—~2.3kAutomated safety check: PassMIT

Similar skills

  • Capture

    alirezarezvani/claude-skills

    Captures and organizes chaotic brain dumps into a structured, actionable system with zero information loss.

    28k GitHub starsUsed in 1 repo~2.8k tokens
    Agent WorkflowsAuto-check passed
  • Lesson Memory Recorder

    rohitg00/agentmemory

    Distills a user correction or hard-won rule into a confidence-weighted lesson that resurfaces automatically before similar future work.

    29k GitHub stars~721 tokensUpdated yesterday
    Agent WorkflowsAuto-check passed
  • Paperclip Distill

    paperclipai/paperclip

    A skill your agent uses when an operation issue is a Paperclip cursor-window, distill, or backfill.

    98k GitHub stars~2.8k tokensUpdated today
    Productivity & AutomationAuto-check passed
  • Rules Distillation

    affaan-m/ECC

    Scans installed skills for principles that recur across them and proposes rule-file changes: append, revise, add a section, create a file or leave as covered.

    274k GitHub starsUsed in 2 repos~2.3k tokens
    Agent WorkflowsAuto-check passed
  • Taste Distillation

    affaan-m/ECC

    Measure a set of reference videos into a reusable style pack - colour grade as a 3D LUT, cut rhythm as a shot-length distribution, hero stills, screen-blend overlay plates, and a text spec for a…

    274k GitHub stars~2.3k tokensUpdated 2 days ago
    Auto-check passed
  • Rules Distill

    affaan-m/ECC

    スキルをスキャンしてドメイン横断的な原則を抽出し、ルールに蒸留する——既存のルールファイルへの追記、修正、または新規作成

    274k GitHub stars~1.5k tokensUpdated 2 days ago
    Auto-check passed

More from NoobyGains/godmode

All 34 skills in this repo
  • Activation

    NoobyGains/godmode

    A skill your agent uses when starting any conversation - establishes how to locate and invoke skills, mandating Skill tool usage before ANY response including clarifying questions

    107 GitHub stars~2.4k tokensUpdated 7 mo ago
    Auto-check passed
  • Agent Messaging

    NoobyGains/godmode

    A skill your agent uses when dispatching subagents, composing prompts for teammates, structuring handoff reports, or managing context boundaries between agents.

    107 GitHub stars~3k tokensUpdated 7 mo ago
    Auto-check passed
  • Codebase Research

    NoobyGains/godmode

    A skill your agent uses when building ANY feature within an existing project - search the current codebase for existing patterns, conventions, similar implementations, and established approaches…

    107 GitHub stars~3.2k tokensUpdated 7 mo ago
    Auto-check: notes
  • Completion Gate

    NoobyGains/godmode

    A skill your agent uses when about to declare work done, fixed, or passing, before committing or opening PRs - demands executing verification commands and reading their output before making any…

    107 GitHub stars~1.6k tokensUpdated 7 mo ago
    Auto-check passed
  • Comprehension Check

    NoobyGains/godmode

    A skill your agent uses when implementing any substantial feature, multi-file modification, or architectural change - produces a plain-language walkthrough of every alteration so the developer can…

    107 GitHub stars~1.5k tokensUpdated 7 mo ago
    Auto-check passed
  • Delegated Execution

    NoobyGains/godmode

    A skill your agent uses when executing implementation plans with independent tasks in the current session

    107 GitHub stars~2.4k tokensUpdated 7 mo ago
    Auto-check passed

Questions about Knowledge Capture

What does Knowledge Capture do?

A skill your agent uses when completing any meaningful task - distill patterns, lessons, and insights from the interaction and persist them for future sessions. Knowledge Capture is an agent skill from NoobyGains/godmode.

When should I use Knowledge Capture?

Knowledge Capture fits situations like: completing any meaningful task - distill patterns; insights from the interaction and persist them for future sessions.

How do I install Knowledge Capture in Claude Code?

Run `npx skills add NoobyGains/godmode --skill knowledge-capture -a claude-code`. Or copy the skill folder (skills/knowledge-capture in NoobyGains/godmode) into .claude/skills/knowledge-capture in your project. Claude Code loads it when a task matches its description.

How do I install Knowledge Capture in Codex?

Run `npx skills add NoobyGains/godmode --skill knowledge-capture -a codex`. Or copy the skill folder (skills/knowledge-capture in NoobyGains/godmode) into .agents/skills/knowledge-capture in your project. Codex loads it when a task matches its description.

Can I use Knowledge Capture in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add NoobyGains/godmode --skill knowledge-capture -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/knowledge-capture, .gemini/skills/knowledge-capture, .github/skills/knowledge-capture and .opencode/skills/knowledge-capture in your project.

What does Knowledge Capture need to run?

Going by SKILL.md and its folder, Knowledge Capture needs the command-line tools its instructions call (pnpm).

Does Knowledge Capture access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Knowledge Capture safe to install?

Our automated static check of SKILL.md found notes only (mentions a .env file), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Knowledge Capture use?

Knowledge Capture is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Knowledge Capture use?

About 2.8k tokens (SKILL.md is roughly 11k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Knowledge Capture?

Skills that share tags, products or a category with Knowledge Capture: Capture (alirezarezvani/claude-skills, 28k stars), Lesson Memory Recorder (rohitg00/agentmemory, 29k stars), Paperclip Distill (paperclipai/paperclip, 98k stars) and Rules Distillation (affaan-m/ECC, 274k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Knowledge Capture?

NoobyGains (a GitHub user) maintains it in NoobyGains/godmode, which has 107 GitHub stars. The repository holds 34 skills in this directory. The repository was last updated on March 9, 2026.

Source: NoobyGains/godmode on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.