Agent skill · Design & Presentation

keep-the-why

Preserves or recovers the reasoning behind a codebase - architectural decisions, rejected alternatives, workarounds, incident learnings, operational constraints, and historical context the code itself cannot explain. Use when implementing or reviewing a non-trivial change involving a design decision, workaround, incident fix, operational constraint, rejected alternative, or changed assumption; when documenting an existing or legacy codebase; during onboarding or a maintainer handover; or when interviewing a developer before their knowledge is lost (e.g. before they leave or retire); or when th

oliver-zehentleitnergithub.com/oliver-zehentleitnerGitHub ↗
claude-codeMIT
Install
npx skills add oliver-zehentleitner/keep-the-why --skill keep-the-why --agent claude-code

Same command for any agent — swap --agent for codex, cursor, copilot.

Facts
Files in the skill folder: 16
SKILL.md size: 23 KB
Bundled scripts: none
Version: 0.6.4
Declared author: Oliver Zehentleitner
Path: skills/keep-the-why/SKILL.md
Open the folder on GitHub →
Where it comes from
Stars: 141
Language: Python

Weekly change comes from our own snapshots, not the repository page — it measures attention, not adoption.

Review
written from the skill's own SKILL.md · Aug 5, 2026

What it does

Keeps the rationale behind codebase decisions, rejected alternatives, incidents, operational constraints, and historical context that the code alone cannot explain. It targets non-trivial changes involving design decisions, workarounds, incident fixes, changed assumptions, or onboarding/handovers, and aims to identify what the code cannot explain. It records rationale alongside the code and asks targeted questions rather than generic ones, maintaining concise, topic-based, version-controlled documentation readable by humans and AI agents.

How it works

The skill prescribes four modes of operation within the same job:

  • Continuous capture: notice and record rationale found in ongoing conversations, including cases where a modification starts but is stopped after discovering why it shouldn’t be touched.
  • Retrospective recovery: given a repository, reconstruct decisions using code, git history, issues, and docs to surface rationale the code cannot explain.
  • Knowledge-transfer interview: analyze the repository to extract rationale or prompt targeted questions to capture tacit knowledge from long-tenured maintainers.
  • Maintenance: keep existing rationale current by resolving contradictions, marking superseded entries, merging duplicates, and splitting large files.

It classifies each entry with Evidence (confirmed, inferred, unknown), adds Source and Verification fields when tracing claims, and records Status (active, superseded, open, needs-review). It avoids inventing rationale; if not confirmable, it marks unknown or asks for clarification. It preserves terminology and updates topic files rather than creating duplicates.

When to use it

Use when rationale is produced by a design decision, a rejected alternative, a workaround, an incident, an operational constraint, a changed assumption, or related context during a non-trivial change, documentation of legacy code, onboarding, handover, or knowledge-transfer interviews. It also applies when the user expresses frustration with this skill itself.

What it can touch

The skill references and records information about design decisions and rationale; it adheres to project and personal workflows, and uses topic-based files to store reasoning content. It relies on maintaining evidence, sources, and verifications and does not overwrite code or commit changes on its own without explicit user instruction.

Caveats

It never invents rationale; it requires confirmation and corroboration when sources conflict. It records Status and Evidence separately and flags conflicts as open rather than resolving them itself. It emphasizes proportionality and avoids over-claiming for obvious or self-evident decisions. It adheres to license terms (MIT) and keeps existing terminology and documentation conventions intact.

From the SKILL.md

# Keep the Why The core job: preserve and recover the reasoning that code alone cannot explain. Because "ask Bob" is not documentation — Keep a Changelog records what changed, this preserves why it changed. ## When to use this skill Four modes, all part of the same job: 1. **Continuous capture** — notice when the current conversation contains rationale worth keeping (a decision, a rejected alternative, a workaround, an incident, a constraint) and record it alongside the code. Includes a change that *didn't* happen: starting to modify or remove something, then stopping after discovering why it shouldn't be touched — that reasoning would otherwise leave no trace at all, since nothing gets committed. See `references/continuous-capture.md`. 2. **Retrospective recovery** — given an existing or legacy repository, find the decisions the code cannot explain by itself, and reconstruct as much as possible from code, git history, issues, and existing docs. 3. **Knowledge-transfer interview** — when a maintainer's knowledge is about to become unavailable, analyze the repository first, then either ask targeted questions about exactly what the code couldn't explain, or — for someone whose knowle

What's inside
Steps it walks through
  1. When to use this skill
  2. Composition with other skills
  3. Core rules
  4. Workflow
  5. 0. Setup check
  6. 1. Inspect
  7. 2. Locate knowledge gaps
  8. 3. Classify the evidence
  9. 4. Ask, or listen
  10. 5. Record
  11. 6. Maintain
  12. Target repository structure
  13. Reference files
  14. What this skill is not
Ships with 15 files
  • evals/README.md
  • evals/evals.json
  • examples/abandoned-change.md
  • examples/continuous-development.md
  • examples/developer-handover.md
  • examples/first-time-setup.md
  • examples/legacy-project.md
  • references/continuous-capture.md
  • references/interview-playbook.md
  • references/methodology.md
  • references/migrations.md
  • references/repository-structure.md
  • references/retrospective-analysis.md
  • references/setup.md
  • references/trust-model.md
About this skill
What does the keep-the-why skill do?

Preserves or recovers the reasoning behind a codebase - architectural decisions, rejected alternatives, workarounds, incident learnings, operational constraints, and historical context the code itself cannot explain. Use when implementing or reviewing a non-trivial change involving a design decision, workaround, incident fix, operational constraint, rejected alternative, or changed assumption; when documenting an existing or legacy codebase; during onboarding or a maintainer handover; or when interviewing a developer before their knowledge is lost (e.g. before they leave or retire); or when th

How do I install it?

Run `npx skills add oliver-zehentleitner/keep-the-why --skill keep-the-why --agent claude-code` — it drops the skill into your project so the agent can pick it up. Swap the --agent value for codex, cursor or copilot if you use one of those.

Where does this skill come from?

From oliver-zehentleitner/keep-the-why, a repository with 141 stars. We read it straight from the repository tree rather than a submitted listing, so what you see here is what is actually published.

Is a popular skill a good skill?

Not necessarily. Stars measure attention, not adoption — a repository can trend for a week and be abandoned. That is why we show the weekly change from our own snapshots next to the total, instead of a single flattering number.

Keep going