Agent skill · Documentation

doc-and-modernize

Two related workflows for a locally-cloned codebase, in one skill. Documentation mode produces a single, comprehensive, verifiable architecture document primarily by reading files on disk (local-first) — use it whenever the user wants to understand, map, document, research, or onboard onto a codebase ("research this repo", "write up the architecture", "do an architecture deep dive", "document how this codebase works", "map the system design", "create an onboarding doc"). Modernization mode generates a phased plan to modernize, migrate, upgrade, or rewrite a legacy system ("modernize this", "pl

GitHub68,948★ · +463/wk · 2 repos on radarProfile →
copilotMIT
Install
npx skills add github/awesome-copilot --skill doc-and-modernize --agent copilot

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

Facts
Files in the skill folder: 3
SKILL.md size: 48 KB
Bundled scripts: none
Path: skills/doc-and-modernize/SKILL.md
Open the folder on GitHub →
Where it comes from
Stars: 37,432 · +281 this week
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

Guides a locally checked-out repository through two workflows: (1) Documentation mode to produce one definitive, cited architecture document describing the codebase from disk, suitable for onboarding and mapping the system; (2) Modernization mode to generate a phased plan to modernize, migrate, upgrade, or rewrite a legacy system. If no architecture document exists, it first runs Documentation mode and then proceeds to the modernization plan.

How it works

  • Documentation mode reads local files to build a single Markdown document with sections: Whole-repo deep-dive, tech-stack, entry points, commands & verification inventory, directory layout, deployment surface, EOL/dependency notes, data/storage, APIs, plugins, CI/CD, and subsystems deep-dives.
  • It anchors to the local checkout identity by executing git commands to verify remote, branch, and commit. It detects technology stacks from manifests and config files on disk. It maps the repo breadth before drilling into 2-3 hardest subsystems. It verifies cited files and line numbers for each claim.
  • Output is a single Markdown document with local-file citations and a structured conventions section emphasizing traceability and [UNVERIFIED] or [INFERRED] as needed.
  • Modernization mode uses the architecture document if available and produces a forward-looking plan with a safety ladder, feasibility spike, and phases for modernization. It avoids assuming a fully-green legacy CI gate and focuses on a time-boxed spike to determine a realistic migration path.

When to use it

  • Use Documentation mode when you want to understand, map, document, research, or onboard onto a codebase (e.g., "research this repo", "write up the architecture", "do an architecture deep dive").
  • Use Modernization mode when you want to modernize, migrate, upgrade, or rewrite a system (e.g., "modernize this", "plan the migration"). If no architecture document exists yet, it will run Documentation mode first.

What it can touch

  • The workflow relies on local files and standard repo manifests (e.g., Go, npm, Python, Java configurations) present in the checked-out repository. It does not rely on remote sources unless necessary for verification notes, which it marks as [UNVERIFIED].

Caveats

  • Assumes a locally checked-out repository and uses a local-first approach; remote facts (like star counts or full CI histories) may be out of scope unless explicitly determined and marked as [UNVERIFIED].
  • The modernization plan emphasizes a safety ladder and feasibility spike rather than guaranteeing a green CI gate before any migration work.
From the SKILL.md

# Documentation & Modernization Two complementary workflows for a repository the user already has checked out locally, bundled as one skill: - **Documentation mode** — produce one definitive, cited architecture document from the code on disk. Ideal for onboarding, system-design maps, or as the evidence base for a modernization effort. - **Modernization mode** — turn that architecture into a phased, safety-laddered plan to upgrade, migrate, or rewrite a legacy system. ## Mode selection - If the user wants to **understand, document, map, research, or onboard onto** a codebase, run **Documentation mode**. - If the user wants to **modernize, migrate, upgrade, or rewrite** a system, run **Modernization mode**. Modernization mode is self-sufficient: if no architecture document exists yet, it runs the **Documentation mode** workflow first (in the same pass), then continues straight through to the plan. When in doubt, produce the architecture document first — it is the audited evidence base both modes rely on. ## Documentation mode Generate one definitive, cited architecture document for a repository the user already has checked out locally. The goal is a writeup someone could hand to a ne

What's inside
Steps it walks through
  1. Mode selection
  2. Documentation mode
  3. Why local-first
  4. Workflow
  5. Output structure
  6. Conventions that make the document trustworthy
  7. Scope control
  8. Modernization mode
  9. Prerequisites
  10. Output Structure
  11. Conventions
Ships with 2 files
  • references/copilot-instructions.template.md
  • references/migration-hazards.md
More from awesome-copilot
All skills →
About this skill
What does the doc-and-modernize skill do?

Two related workflows for a locally-cloned codebase, in one skill. Documentation mode produces a single, comprehensive, verifiable architecture document primarily by reading files on disk (local-first) — use it whenever the user wants to understand, map, document, research, or onboard onto a codebase ("research this repo", "write up the architecture", "do an architecture deep dive", "document how this codebase works", "map the system design", "create an onboarding doc"). Modernization mode generates a phased plan to modernize, migrate, upgrade, or rewrite a legacy system ("modernize this", "pl

How do I install it?

Run `npx skills add github/awesome-copilot --skill doc-and-modernize --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 github/awesome-copilot, a repository with 37,432 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