record-case

Convert debugging outcomes and technical decisions into evidence-backed Case, Decision, and Pattern records.

1|Updated May 17, 2026
One-click install
npx skills add https://github.com/mykcs/myk-skills --skill record-case
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: record-case
Source: https://github.com/mykcs/myk-skills/tree/main/record-case
Command: npx skills add https://github.com/mykcs/myk-skills --skill record-case

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you systematically archive what you learned from debugging, repeated workflow mistakes, and technical decisions so it becomes searchable, reusable knowledge instead of staying trapped in chat logs.

Core Features & Use Cases

  • Case/Pattern/Decision routing: Automatically classifies your knowledge into Case (deep), Decision (architecture choice), or Pattern (lightweight workflow preference) using clear priority rules (Case > Decision > Pattern).
  • Deep Case quality guardrails: Enforces a structured, evidence-based format with failure-path reconstruction, non-trivial decision rationale, and trigger-style “IF...THEN...ELSE...” lessons to ensure the archive is actually useful.
  • Indexing and duplication prevention: Writes to the correct storage path, appends to MEMORY.md under ## Cases, and checks for duplicates via keyword grep before committing.
  • Missing-information follow-up: If the user provides insufficient details (e.g., no observable symptoms, no commands, no environment/version), it asks targeted questions rather than guessing.

Quick Start

Record a bug fix or a workflow lesson by telling the AI to “record this /归档/留档/case 一下/学到了,” and include the key symptoms, what you tried, and how you verified the final outcome.

Frequently Asked Questions about record-case

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

FAQPage Schema
How do I archive debugging outcomes into reusable knowledge?

To archive debugging outcomes into reusable knowledge, you provide the symptoms, attempts, and verified results, and the system extracts facts to generate evidence-backed Case, Decision, or Pattern records. It routes content by priority and enforces structured failure-path reconstruction.

What is the best way to maintain a technical decision log for postmortems?

Maintaining a technical decision log for postmortems requires evidence-based documentation that captures non-trivial decision rationale and trigger-style lessons. The system classifies entries into Decision templates and appends them to a memory index with duplication prevention.

How do I record workflow mistakes so they become searchable memory?

Recording workflow mistakes into searchable memory involves stepwise extraction of facts from the event to create lightweight Pattern records. These records append directly to your memory index under dedicated sections, preventing future repeated errors.

Does the knowledge management system check for duplicate case archives?

Yes, the knowledge management system checks for duplicate case archives by performing a keyword grep before committing. It ensures new evidence-backed records are appended correctly without redundant entries in your stored memory index.

What happens if I provide insufficient details for a postmortem record?

If you provide insufficient details for a postmortem record, the system asks targeted follow-up questions instead of guessing. It requires observable symptoms, commands, and environment or version information to enforce deep Case quality guardrails.

When should I route a debugging lesson to a Case versus a Pattern template?

Routing a debugging lesson to a Case versus a Pattern template depends on depth: Cases require deep evidence-backed failure-path reconstruction, while Patterns are lightweight workflow preferences. The system automatically prioritizes Case > Decision > Pattern.