Skip to content
cccskills
FreePublished on GitHub

memory-capture

Capture durable project memory from work, debates, debugging discoveries, learned conventions, deferred options, and session outcomes. Load when the user says remember this, save this learning, record what happened, update project memory, or preserve context for future agents.

The English summary is being prepared. Showing the original description.

See how to install

Files included (2)

  • SKILL.md4.5 KB
  • references/examples.md1.7 KB

SKILL.md (original)

Review the instructions the agent will receive before you install.

Memory Capture

You turn useful session context into structured project memory. Capture only what a future agent would need to avoid rework or bad assumptions.

Workflow

  1. Identify the memory type: state, decision, learning, deferred item, open question, session event, or handoff.
  2. Reject trivial, temporary, duplicate, sensitive, or already-obvious content.
  3. If the item is a reusable skill/process rule, route to learn-from-chat instead.
  4. If content came from external files, URLs, pasted transcripts, or repos, run all secure-* skills first.
  5. Write project-scoped memory to the matching file in docs/memory/.
  6. Update docs/memory/project-index.md with date, tags, file, status, confidence, and source.
  7. If the memory is cross-project, call memory-promote instead of writing global memory directly.
  8. Append file changes to docs/skill-outputs/SKILL-OUTPUTS.md.
  9. Tell the user what was saved and what was rejected.

Hard Rules

  • Project first; global only through memory-promote.
  • Do not store secrets, credentials, or unnecessary personal data.
  • Do not capture raw long transcripts; summarize with provenance.
  • Do not append if the target entry already exists; update status or merge.
  • Never overwrite a richer memory entry with a thinner summary without archiving the prior version.
  • If compaction would drop decisions or revisit triggers, route to memory-compact instead of truncating inline.

Memory Type Map

TypeFile
current statedocs/memory/current-state.md
decisionmemory-decision
session detaildocs/memory/session-log.md
project learningdocs/memory/learnings.md
maybe / parked ideadocs/memory/deferred.md
unresolved questiondocs/memory/open-questions.md
next-agent summarymemory-handoff

Capture Template

Use this template only for state, learning, deferred, question, or session captures. Decisions use the template in memory-decision; next-agent summaries use the template in memory-handoff.

## YYYY-MM-DD - <short title>
Type: state | learning | deferred | question | session
Status: active | deferred | resolved | superseded
Scope: project
Confidence: high | medium | low
Source: <chat/session/file/commit>
Tags: <comma-separated>

### Content
<concise durable memory>

### Why It Matters
<how future agents should use it>

### Revisit When
<conditions or "not applicable">

Hard Rules

  • Project first; global only through memory-promote.
  • Do not store secrets, credentials, or unnecessary personal data.
  • Do not capture raw long transcripts; summarize with provenance.
  • Do not append if the target entry already exists; update status or merge.

Example

Input: "Remember that we chose repo memory plus global memory, but global must stay tiny."

Output: write to docs/memory/decision-log.md via memory-decision, then index it.

Common Rationalizations

ExcuseReality
Skip memory — just codeNext agent loses decisions, blockers, and approved scope.
Load every memory fileRead indexes and handoff tail only — bounded context.
Global memory for everythingProject memory default; global only when stable and cross-project.
External paste → memoryRun secure-* first; transform to agent-authored notes.

Verification

  • Correct sub-skill routed with reason
  • No secrets or raw transcripts persisted
  • Files changed listed in Impact Report
  • Security gate noted when external content involved

Red Flags

  • Raw long transcript captured instead of summarized note
  • Capture written directly to global without promote path
  • Secrets or credentials included in captured note
  • Capture lacks provenance or source attribution

Prune Log

Last pruned: 2026-07-04

  • No changes — citation audit passed; content current (improve-skills full pass 2026-07-04)

Impact Report

After completing, report:

Memory captured: <title>
Type: <type>
Location: <path>
Indexed: yes/no
Rejected items: <count and reason>
Promotion suggested: yes/no

Reviews

No reviews yet. Tell others what you thought.

Comments

No login needed. Share how it worked for you, ask a question, or note where it did not run.

No comments yet. Be the first to write one.

Comments are published right away. Do not include personal information such as email addresses or phone numbers. Up to 2 URLs.

0 / 1,000 characters

This form is protected by reCAPTCHA, and the Google Privacy Policy and Terms of Service apply.

More skills from this repository

Put on the adversarial hat and systematically attack any document, plan, strategy, or idea to expose its weakest points before commitment. Structured devil's advocate with red team rigour — not pessimism, but evidence-based critique across three phases: diagnostic (are claims accurate?), creative (is the problem artificially constrained?), challenge (are solutions robust?). Load when the user asks to stress test a document, red team this plan, poke holes in this, devil's advocate this, challenge my assumptions, or when product-soul, brainstorming, prd-writing, or inversion calls for adversarial review. Also triggers on "what am I missing", "what could kill this", "find the flaws", or "critique this rigorously".

The English summary is being prepared. Showing the original description.

dvy1987/agent-loom3Updated Aug 8, 2026

Design execution structure for decomposed processes: single agent or multi-agent topology. Load when user says "design an agent for this", "what agent structure do I need", "architect this", "should this be multi-agent", "what's the right execution structure", "agent topology", "how should agents be organized". Takes process-decomposer output as primary input. If triggered directly without a process entry, calls process-decomposer first.

The English summary is being prepared. Showing the original description.

dvy1987/agent-loom3Updated Aug 8, 2026

Internal skill. Called by setup-evaluation after a PASS. Launches agents from a validated architecture spec using Claude Code / Ampcode native parallelism (Task tool). Does NOT generate scripts or SDK code — it outputs structured spawn instructions that the platform executes natively. Never invoked directly by the user. Never launches without a setup-evaluation PASS.

The English summary is being prepared. Showing the original description.

dvy1987/agent-loom3Updated Aug 8, 2026

Sync library skills from an agent-loom upstream repo into this project's .agents/skills while preserving project-local and forked skills. Load when the user asks to sync agent-loom, update skills from upstream, rsync from ../agent-loom, pull new library skills, upgrade installed skills, or refresh the .agents folder without losing custom project skills. Also triggers on "sync skills from agent-loom", "update my agent skills", "pull skill library updates", or "merge agent-loom improvements into this repo".

The English summary is being prepared. Showing the original description.

dvy1987/agent-loom3Updated Aug 8, 2026

Instrument a shipped product's AI agents with tracing and observability so you can see what they did, why outputs happened, and what each run cost. Plain-language primer plus free-tier-first backend selection (Langfuse, Phoenix, LangSmith, Braintrust) and OpenTelemetry/OpenInference instrumentation. Load when the user asks to add observability, add tracing, instrument my agents, see what my agent is doing in production, set up Langfuse or Phoenix or LangSmith, debug why my agent gave a bad answer, or track LLM cost per request. Also fires when agent-system-architecture or setup-evaluation requires an observability plan for an agent-chain product. NOT for tracing the coding agent itself — that is run-trace. Precondition for runtime-learning-loop.

The English summary is being prepared. Showing the original description.

dvy1987/agent-loom3Updated Aug 8, 2026

Run a structured retrospective after development-phase runs of your product's agents — interview the owner in plain language about what went well and poorly, draft ranked improvement hypotheses, then design and run small n=1/n=2 experiments with pre-declared success criteria, guardrails, stop conditions, and a cost/ROI kill-switch. Load when the user says how did that run go, retro this run, the agent output was bad, what should we improve, draft hypotheses, run a small experiment, or after repeated dev runs of an agentic system produce uneven quality. Priority: output quality over performance over cost, each with diminishing-returns stops. NOT a product A/B test (experimentation), NOT coding-agent harness repair (harness-evolution), NOT production-scale learning (runtime-learning-loop).

The English summary is being prepared. Showing the original description.

dvy1987/agent-loom3Updated Aug 8, 2026

See all skills by dvy1987

Report a problem with this skill