home / skills / duc01226 / easyplatform / docs-init

docs-init skill

safe

This skill analyzes the codebase, organizes project structure, and generates initial documentation across project overview, codebase, standards, and

npx playbooks add skill duc01226/easyplatform --skill docs-init

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

1.9 KB

---
name: docs-init
description: "[Docs] ⚡⚡⚡⚡ Analyze the codebase and create initial documentation"
infer: true
---

## Phase 1: Parallel Codebase Scouting

**You (main agent) must spawn scouts** - subagents cannot spawn subagents.

1. Run `ls -la` to identify actual project directories
2. Spawn 2-4 `scout-external` (preferred, uses Gemini 2M context) or `scout` (fallback) via Task tool
3. Target directories **that actually exist** - adapt to project structure, don't hardcode paths
4. Merge scout results into context summary

## Phase 2: Documentation Creation (docs-manager Agent)

Pass the gathered file list to `docs-manager` agent to create initial documentation:
- `docs/project-overview-pdr.md`: Project overview and PDR (Product Development Requirements)
- `docs/codebase-summary.md`: Codebase summary
- `docs/code-standards.md`: Codebase structure and code standards
- `docs/system-architecture.md`: System architecture
- Update `README.md` with initial documentation (keep it under 300 lines)

Use `docs/` directory as the source of truth for documentation.

## [CRITICAL] Code Evidence Requirements

All documentation MUST follow evidence rules from `.claude/skills/feature-docs/SKILL.md` → `[CRITICAL] MANDATORY CODE EVIDENCE RULE`

### Quick Reference
- **Format**: `**Evidence**: {FilePath}:{LineNumber}`
- **Status**: ✅ Verified / ⚠️ Stale / ❌ Missing
- **Verification**: 3-pass verification required before completion

### Evidence Verification Table (Required)
| Entity/Component | Documented Lines | Actual Lines | Status     |
| ---------------- | ---------------- | ------------ | ---------- |
| `Entity.cs`      | L6-15            | L6-15        | ✅ Verified |

**IMPORTANT**: **Do not** start implementing.

## IMPORTANT Task Planning Notes

- Always plan and break many small todo tasks
- Always add a final review todo task to review the works done at the end to find any fix or enhancement needed

Overview

This skill analyzes a C# codebase and produces an initial set of developer-facing documentation. It runs an organized scouting pass across existing directories, merges findings, and orchestrates a docs-manager phase to generate structured docs under docs/. The output emphasizes evidence-backed statements and a final README update.

How this skill works

The skill first performs a parallel scouting phase by listing project directories and spawning 2–4 scout subagents targeted only at directories that actually exist. Scout outputs are merged into a concise context summary. Next, a docs-manager agent consumes the gathered file list to generate a project overview, codebase summary, code standards, system architecture, and an updated README under docs/. All documentation entries must include mandatory code-evidence markers with 3-pass verification and an evidence verification table.

When to use it

Onboarding a new project with little or no documentation
Before major refactors to capture current architecture and standards
When preparing an initial developer handoff or audit package
To create a documented baseline for automated or manual QA
When formalizing code evidence for compliance or review

Best practices

Always run an ls-style discovery to target real directories rather than hardcoding paths
Spawn 2–4 scout agents and adapt their targets to the repository structure
Merge scout results into a single context summary before generating docs
Include the required evidence lines in the format **Evidence**: {FilePath}:{LineNumber} for every claimed fact
Perform a 3-pass verification for every evidence item and include an evidence verification table in the docs
Break work into small TODO tasks and add a final review task to validate completeness

Example use cases

Create docs for a legacy C# service to accelerate new developer onboarding
Generate a project overview and architecture summary prior to a security review
Produce a baseline README and code standards for an open-source release
Document entity-to-line mappings needed for compliance or audit traces
Summarize multi-project workspaces for product planning meetings

FAQ

How many scout subagents should run?

Spawn 2–4 scouts. Prefer scout-external; fall back to scout if necessary. Target only directories discovered by the initial ls pass.

What is the required evidence format?

Every documented claim must include **Evidence**: {FilePath}:{LineNumber} and a verification status. Include an evidence verification table and perform a 3-pass verification for completeness.