agentleFS
neeraj181-dotneeraj181-dot/ClaudeSkills/.claude/skills/context-keeper/SKILL.md

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.

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
  1. Very specific:

    Read-only on the project: Do not modify code, do not delete files, do not change Git state (no commit/reset/push).

    line 23
  2. Distinctive:

    Stay in scope: Never expose secrets; never touch unrelated projects.

    line 24
  3. Very specific:

    Read manifests and configs (package.json, requirements.txt/pyproject.toml, composer.json, pom.xml/build.gradle, pubspec.yaml, go.mod, …

    line 34
  4. Distinctive:

    Document configuration sources: environment variables · config files · runtime settings · build variables · database config · API config · …

    line 62
  5. Very specific:

    Never display actual secret values: Use placeholders: DATABASE_URL=<configured>, STRIPE_KEY=<configured>.

    line 64
  6. Distinctive:

    If the project uses Git, inspect (read-only): current branch · remote repository · recent commits · major branches · recently-active …

    line 68
  7. Very specific:

    Write PROJECT_CONTEXT.md in the project root, with these sections:

    line 86
  8. Distinctive:

    Keep it factual and concise.

    line 110
  9. Very specific:

    If PROJECT_CONTEXT.md already exists, do not blindly overwrite it.

    line 114
  10. Very specific:

    When invoked in a project that already contains PROJECT_CONTEXT.md:

    line 120
  11. Distinctive:

    Use the resulting knowledge to orient before any other development task.

    line 126
  12. Distinctive:

    After building or updating the map, report concisely:

    line 132

≈ “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.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

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:

  1. 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.
  2. 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 Notes

Keep 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:

  1. Read it first.
  2. Verify important claims against the actual project — never blindly trust stale documentation.
  3. Identify what changed since it was written.
  4. Update the map where reality has diverged.
  5. Use the resulting knowledge to orient before any other development task.

Final response

After building or updating the map, report concisely:

  1. Project type
  2. Technology stack
  3. Main architecture
  4. Major features
  5. Important entry points
  6. Important dependencies
  7. Sensitive areas
  8. What was added or updated in PROJECT_CONTEXT.md
  9. 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.

Download now (ZIP)

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
What did you use it for? e.g. Reviewing pull requests in a Rails app

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.