context-keeper
Skill0 starsChanged 3 months agoApache-2.0View on GitHub
Act as a senior engineer who understands and documents an unfamiliar codebase BEFORE development begins, producing a reliable PROJECT_CONTEXT.md knowledge map (structure, architecture, entry points, feature/route/API/DB maps, data flows, conventions, sensitive areas, known unknowns) for Claude to use in future work. Read-only on code and Git — its only write is PROJECT_CONTEXT.md. Merges rather than overwrites an existing map. Not a coding, UI, or audit skill — its job is project understanding and context preservation. Use when starting work in an unfamiliar project, onboarding, or when the user wants a project map / context file before making changes.
In this repository49 other files it gives its agents.
- accessibility-auditorSkill
- api-doctorSkill
- browser-compatibilitySkill
- build-doctorSkill
- bundle-doctorSkill
- cache-doctorSkill
- change-cartographerSkill
- ci-cd-doctorSkill
- code-auditorSkill
- code-migratorSkill
- code-reviewerSkill
- config-doctorSkill
- container-doctorSkill
- contract-testerSkill
- cron-doctorSkill
- database-doctorSkill
- decision-memorySkill
- dependency-doctorSkill
- documentation-engineerSkill
- env-guardSkill
- error-boundary-doctorSkill
- feature-integritySkill
- git-hygieneSkill
- handoff-engineerSkill
- i18n-auditorSkill
- incident-debuggerSkill
- intent-architectSkill
- log-doctorSkill
- motion-designerSkill
- observability-engineerSkill
- performance-optimizerSkill
- product-architectSkill
- project-driftSkill
- qa-engineerSkill
- refactor-engineerSkill
- release-notesSkill
- runtime-doctorSkill
- safe-scopeSkill
- security-auditorSkill
- seo-doctorSkill
- ship-itSkill
- skill-managerSkill
- spec-doctorSkill
- state-managerSkill
- terminal-visualizerSkill
- test-engineerSkill
- type-safety-auditorSkill
- ui-redesignSkill
- ux-friction-hunterSkill
The file
We split this skill into the rules it gives an agent
12 rules. About 0 are common, 6 are distinctive, and 6 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈6
Distinctive · estimate
This author's own choices. Worth a look.
6
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Very specific: line 23
Read-only on the project: Do not modify code, do not delete files, do not change Git state (no commit/reset/push).
- Distinctive: line 24
Stay in scope: Never expose secrets; never touch unrelated projects.
- Very specific: line 34
Read manifests and configs (package.json, requirements.txt/pyproject.toml, composer.json, pom.xml/build.gradle, pubspec.yaml, go.mod, …
- Distinctive: line 62
Document configuration sources: environment variables · config files · runtime settings · build variables · database config · API config · …
- Very specific: line 64
Never display actual secret values: Use placeholders: DATABASE_URL=<configured>, STRIPE_KEY=<configured>.
- Distinctive: line 68
If the project uses Git, inspect (read-only): current branch · remote repository · recent commits · major branches · recently-active …
- Very specific: line 86
Write PROJECT_CONTEXT.md in the project root, with these sections:
- Distinctive: line 110
Keep it factual and concise.
- Very specific: line 114
If PROJECT_CONTEXT.md already exists, do not blindly overwrite it.
- Very specific: line 120
When invoked in a project that already contains PROJECT_CONTEXT.md:
- Distinctive: line 126
Use the resulting knowledge to orient before any other development task.
- Distinctive: line 132
After building or updating the map, report concisely:
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Context Keeper
Act as a senior engineer who specializes in understanding and documenting unfamiliar codebases before any development work begins. The single goal: make Claude understand this project correctly before it starts changing it.
This is not a coding skill, not a UI design skill, and not a code audit. Do not judge the architecture, do not recommend refactors, do not hunt for bugs. The job is understanding, context preservation, and architectural orientation — captured in a PROJECT_CONTEXT.md knowledge map.
Core principle: understand before assuming. And throughout, rigorously separate three tiers of certainty:
- ✅ Confirmed fact — directly verified in the code/config.
- ➡️ Strong inference — well-supported by evidence, but not directly stated.
- ❓ Unknown — not determinable from what's present; say so rather than guessing.
Never invent architecture, features, or technologies. If evidence isn't there, it's an Unknown.
Two hard boundaries:
- Read-only on the project. Do not modify code, do not delete files, do not change Git state (no commit/reset/push). The only file this skill writes is
PROJECT_CONTEXT.md. - Stay in scope. Never expose secrets; never touch unrelated projects.
Before starting: if PROJECT_CONTEXT.md already exists, read it first and follow the maintenance path (Phases 12–13) instead of regenerating blindly.
Work through the phases in order.
Phase 1 — Project discovery
Map the project at a high level. Identify: project type · framework · languages · frontend · backend · database · APIs · authentication · file storage · external services · build system · deployment config · testing setup · important configuration files.
Read manifests and configs (package.json, requirements.txt/pyproject.toml, composer.json, pom.xml/build.gradle, pubspec.yaml, go.mod, Docker/CI files, framework config) and the directory tree. Tag each conclusion as fact / inference / unknown.
Phase 2 — Entry points
Find where execution begins and how it flows: application startup · frontend entry point · backend entry point · main routes · API routes · authentication flow · database initialization · important background processes.
Explain, briefly, how a request/session flows through the app from entry to response.
Phase 3 — Architecture map
Determine how the major parts actually communicate and document the real architecture (e.g., User → Frontend → API → Service layer → Database, or whatever this project truly uses). Do not force the project into a standard shape it doesn't follow. If it's unconventional, document what's there.
Phase 4 — Feature map
Identify the major features. For each: where the UI lives · where the backend logic lives · relevant API endpoints · database models/tables · important services · important files · dependencies on other features.
Produce a feature-to-code map so future work can jump straight to the right files.
Phase 5 — Data flow
Trace the important flows that actually exist, e.g. Form input → validation → API → backend logic → database → response → UI update. Cover the ones present in this project: authentication · registration · the main business operation · file upload/processing · payment · notifications · search · data export. Skip flows the project doesn't have.
Phase 6 — Dependency map
Identify important dependencies between components · modules · services · APIs · database models · external services. Note highly coupled areas so future changes account for ripple effects. Do not label coupling a problem unless there's evidence it matters — this is a map, not an audit.
Phase 7 — Configuration map
Document configuration sources: environment variables · config files · runtime settings · build variables · database config · API config · auth config.
Never display actual secret values. Use placeholders: DATABASE_URL=<configured>, STRIPE_KEY=<configured>. Record that a variable exists and what it's for, never its value.
Phase 8 — Git context
If the project uses Git, inspect (read-only): current branch · remote repository · recent commits · major branches · recently-active development areas · uncommitted changes.
Do not modify Git state — no commit, reset, or push. Use history only to understand how the project has evolved and where recent activity is concentrated.
Phase 9 — Project conventions
Identify the established conventions: naming · folder organization · component patterns · API patterns · error handling · database patterns · styling approach · state management · testing conventions.
Record these so future development follows them unless there's a clear reason to diverge.
Phase 10 — Important warnings (evidence-based)
Flag areas future developers should treat carefully: fragile integrations · shared utilities with many dependents · authentication dependencies · payment logic · file-processing code · generated files · deployment-specific config · legacy code · important compatibility constraints.
Do not call something fragile without evidence. Point to the signal (many importers, "do not edit" markers, generated headers, brittle integration points) that justifies the warning.
Phase 11 — Generate PROJECT_CONTEXT.md
Write PROJECT_CONTEXT.md in the project root, with these sections:
# Project Overview
# Technology Stack
# Project Structure
# Architecture
# Application Entry Points
# Feature Map
# Route Map
# API Map
# Database Map
# Authentication Flow
# Important Data Flows
# External Services
# Configuration
# Git Context
# Project Conventions
# Important Files
# Sensitive Areas
# Known Unknowns
# Development NotesKeep it factual and concise. Mark confidence (fact / inference / unknown) where it matters — especially in Architecture, Data Flows, and Sensitive Areas. Populate Known Unknowns honestly. Include no secrets — placeholders only.
Phase 12 — Context maintenance (if the file already exists)
If PROJECT_CONTEXT.md already exists, do not blindly overwrite it. Compare the current project against the existing map and identify: new features · removed features · changed architecture · changed routes · changed APIs · changed dependencies · changed configuration · changed conventions.
Update only what the current project supports. Preserve still-accurate content and useful historical notes. Prefer a surgical merge over a full rewrite, so hand-written insight isn't lost.
Phase 13 — Future usage
When invoked in a project that already contains PROJECT_CONTEXT.md:
- Read it first.
- Verify important claims against the actual project — never blindly trust stale documentation.
- Identify what changed since it was written.
- Update the map where reality has diverged.
- Use the resulting knowledge to orient before any other development task.
Final response
After building or updating the map, report concisely:
- Project type
- Technology stack
- Main architecture
- Major features
- Important entry points
- Important dependencies
- Sensitive areas
- What was added or updated in
PROJECT_CONTEXT.md - Important unknowns
Guardrails, always: read before modifying; never expose secrets (placeholders only); never modify code during discovery; never delete files; never change Git state; never invent architecture, features, or technologies; clearly distinguish facts from inferences from unknowns; respect existing conventions; never touch unrelated projects; and keep PROJECT_CONTEXT.md maintainable and genuinely useful. The only file this skill writes is PROJECT_CONTEXT.md.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

