memory-reflection

Capture post-task learnings and write structured reflections to .claude/context_reflections.md.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/kpiteira/ktrdr --skill memory-reflection
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: memory-reflection
Source: https://github.com/kpiteira/ktrdr/tree/main/.claude/skills/memory-reflection
Command: npx skills add https://github.com/kpiteira/ktrdr --skill memory-reflection

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps users avoid repeatedly searching for the same information or re-discovering patterns, by systematically capturing learnings and context gaps after tasks. This saves time and reduces cognitive load, allowing you to focus on new challenges.

Core Features & Use Cases

  • Structured Learning Capture: Guides you to reflect on architectural gaps, pattern re-discovery, and cross-module dependencies encountered during a work session.
  • Memory Recommendations: Suggests what knowledge is truly worth remembering (e.g., core architectural patterns) versus what is easily re-discoverable with a quick search.
  • Efficiency Estimation: Provides a rough assessment of the time saved by avoiding future searches and re-reading of files.
  • Use Case: After a complex debugging session where you traced a bug through multiple services, use this skill to document the interaction patterns and non-obvious dependencies you uncovered, ensuring you don't have to re-learn them next time.

Quick Start

After completing the task, reflect on the session and use the memory-reflection skill to generate a structured reflection.

Frequently Asked Questions about memory-reflection

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I capture learnings from debugging sessions to avoid re-discovering the same issues?

Capture learnings by reflecting on your debugging session to document context gaps, interaction patterns, and non-obvious dependencies you uncovered. This Skill guides you to write structured reflections identifying what's worth remembering versus what's easily re-discoverable, saving time on future similar tasks.

What should I document after a complex development task to improve future efficiency?

Document architectural patterns, cross-module dependencies, and context gaps encountered during your work. This Skill generates structured reflections written to .claude/context_reflections.md with sections for Context Gaps, Memory Recommendations, and an Efficiency Estimate showing time saved by avoiding future re-research.

How do I know which technical knowledge is worth remembering versus what I can quickly look up?

This Skill distinguishes core architectural patterns and non-obvious interaction patterns—worth committing to memory—from easily re-discoverable information. It prioritizes recommendations based on how frequently you'll encounter the same pattern and how much time re-discovery would cost.

Can I use memory reflection across different types of work like research, debugging, and feature development?

Yes. This Skill supports post-task reflections across debugging, research, and development scenarios. It systematically captures learnings and context gaps common to all three, helping you avoid repeated work regardless of task type.

How does capturing work reflections reduce cognitive load and improve my workflow?

By systematically documenting patterns and gaps after each task, you build a reference of lessons learned without re-reading files or searching repeatedly. This frees mental energy for new challenges instead of re-discovering known information.

What output does this Skill produce that I can reference later?

This Skill writes structured reflections to .claude/context_reflections.md containing Context Gaps, Memory Recommendations prioritized by reusability, and an Efficiency Estimate. This becomes a persistent record you reference to accelerate similar future work.