Project Docs
Turn a messy or empty repo into accurate ARCHITECTURE, API, and database docs your agent and future you can trust.
Overview
Project-docs is an agent skill most often used in Build (also Ship onboarding contexts) that generates ARCHITECTURE.md, API_ENDPOINTS.md, and DATABASE_SCHEMA.md by analysing your live codebase.
Install
npx skills add https://github.com/jezweb/claude-skills --skill project-docsWhat is this skill?
- Detects project type from root indicators (Worker, Next.js, Hono, Drizzle, Python, Rust, and more)
- Produces ARCHITECTURE.md, API_ENDPOINTS.md, and DATABASE_SCHEMA.md from actual code—not wishful diagrams
- Workflow: scan → analyse routes/schema/config → write structured markdown with Read/Write/Glob/Grep/Bash
- Use after greenfield setup, stale docs, onboarding, or post-refactor refresh
- Claude Code–only skill with explicit allowed-tools list for safe repo analysis
- 3 named deliverables: ARCHITECTURE.md, API_ENDPOINTS.md, DATABASE_SCHEMA.md
Adoption & trust: 783 installs on skills.sh; 841 GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
Your product evolved faster than the README, so nobody—including your agent—has a trustworthy map of architecture, endpoints, or schema.
Who is it for?
Solo builders who ship full-stack or API repos and want docs regenerated from code after refactors or before handing work to an agent.
Skip if: Teams that already maintain generated OpenAPI/Swagger as the single source of truth and forbid parallel API markdown, or repos with no readable source structure to analyse.
When should I use this skill?
Triggers: 'generate docs', 'document architecture', 'create api docs', 'document schema', 'project documentation', 'write architecture doc'.
What do I get? / Deliverables
You get structured markdown docs grounded in current source so onboarding and agent tasks reference the same ground truth.
- ARCHITECTURE.md
- API_ENDPOINTS.md
- DATABASE_SCHEMA.md
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Documentation generation is anchored in Build because it reads live source, routes, and schema—the core product artifact phase. The skill’s outputs are structured markdown docs (architecture, endpoints, schema), which maps directly to the docs subphase.
Where it fits
Greenfield API with Hono routes—generate API_ENDPOINTS.md before the first external integration.
Post-Drizzle migration—refresh DATABASE_SCHEMA.md so agents stop citing old columns.
Pre-launch checklist—confirm ARCHITECTURE.md matches production wiring.
Six months of feature flags later—re-run doc generation so iterate work does not break hidden dependencies.
How it compares
Use instead of asking the agent to freestyle a README from memory—this skill enforces a detect-analyse-write workflow tied to named doc files.
Common Questions / FAQ
Who is project-docs for?
Solo and indie developers using Claude Code who need architecture, API, and database documentation that matches what is actually in the repository.
When should I use project-docs?
At project kickoff in Build/docs, before onboarding a contributor, after a large refactor in Ship, or whenever docs are missing or stale and you need agent-friendly structure.
Is project-docs safe to install?
The skill requests Read, Write, Edit, Glob, Grep, and Bash to scan and write markdown; review the Security Audits panel on this page before enabling it on sensitive repos.
SKILL.md
READMESKILL.md - Project Docs
# Project Documentation Generator Generate structured project documentation by analysing the codebase. Produces docs that reflect the **actual code**, not aspirational architecture. ## When to Use - New project needs initial documentation - Docs are missing or stale - Onboarding someone to the codebase - Post-refactor doc refresh ## Workflow ### 1. Detect Project Type Scan the project root to determine what kind of project this is: | Indicator | Project Type | |-----------|-------------| | `wrangler.jsonc` / `wrangler.toml` | Cloudflare Worker | | `vite.config.ts` + `src/App.tsx` | React SPA | | `astro.config.mjs` | Astro site | | `next.config.js` | Next.js app | | `package.json` with `hono` | Hono API | | `src/index.ts` with `Hono` | API server | | `drizzle.config.ts` | Has database layer | | `schema.ts` or `schema/` | Has database schema | | `pyproject.toml` / `setup.py` | Python project | | `Cargo.toml` | Rust project | ### 2. Ask What to Generate ``` Which docs should I generate? 1. ARCHITECTURE.md — system overview, stack, directory structure, key flows 2. API_ENDPOINTS.md — routes, methods, params, response shapes, auth 3. DATABASE_SCHEMA.md — tables, relationships, migrations, indexes 4. All of the above ``` Only offer docs that match the project. Don't offer API_ENDPOINTS.md for a static site. Don't offer DATABASE_SCHEMA.md if there's no database. ### 3. Scan the Codebase For each requested doc, read the relevant source files: **ARCHITECTURE.md** — scan: - `package.json` / `pyproject.toml` (stack, dependencies) - Entry points (`src/index.ts`, `src/main.tsx`, `src/App.tsx`) - Config files (`wrangler.jsonc`, `vite.config.ts`, `tsconfig.json`) - Directory structure (top 2 levels) - Key modules and their exports **API_ENDPOINTS.md** — scan: - Route files (`src/routes/`, `src/api/`, or inline in index) - Middleware files (auth, CORS, logging) - Request/response types or Zod schemas - Error handling patterns **DATABASE_SCHEMA.md** — scan: - Drizzle schema files (`src/db/schema.ts`, `src/schema/`) - Migration files (`drizzle/`, `migrations/`) - Raw SQL files if present - Seed files if present ### 4. Generate Documentation Write each doc to `docs/` (create the directory if it doesn't exist). If the project already has docs there, offer to update rather than overwrite. For small projects with no `docs/` directory, write to the project root instead. ## Document Templates ### ARCHITECTURE.md ```markdown # Architecture ## Overview [One paragraph: what this project does and how it's structured] ## Stack | Layer | Technology | Version | |-------|-----------|---------| | Runtime | [e.g. Cloudflare Workers] | — | | Framework | [e.g. Hono] | [version] | | Database | [e.g. D1 (SQLite)] | — | | ORM | [e.g. Drizzle] | [version] | | Frontend | [e.g. React 19] | [version] | | Styling | [e.g. Tailwind v4] | [version] | ## Directory Structure [Annotated tree — top 2 levels with purpose comments] ## Key Flows ### [Flow 1: e.g. "User Authentication"] [Step-by-step: request → middleware → handler → database → response] ### [Flow 2: e.g. "Data Processing Pipeline"] [Step-by-step through the system] ## Configuration [Key config files and what they control] ## Deployment [How to deploy, environment variables needed, build commands] ``` ### API_ENDPOINTS.md ```markdown # API Endpoints ## Base URL [e.g. `https://api.example.com` or relative `/api`] ## Au