Technical Documentation Engine
Complete technical documentation system — from planning through maintenance. Covers READMEs, API docs, guides, architecture docs, runbooks, and developer portals. Includes templates, quality scoring, and automation.
Install / Use
npx skills add LeoYeAI/openclaw-master-skills --skill afrexai-technical-docsInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
AutomationSupported Platforms
Our assessment of Technical Documentation Engine
Technical Documentation Engine scores 90/100 on our quality scale, 1224th of 2,790 Automation skills we index (top 44%).
Its SKILL.md is 28 KB long, well organised into 145 sections with 23 code examples: a thorough specification that gives an agent plenty to work with.
With 2,149 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
- Our last check on 2026-10-30 found the source still online.
- It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 98/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-09-30. Automated pattern scan on 2026-09-30. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
Technical Documentation Engine compared with similar skills
All 4 of these similar skills score higher than Technical Documentation Engine; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| Technical Documentation Engine (this skill)by LeoYeAI | 90 | 2.1k | 4mo ago | SKILL.md |
| Agent-Reachby Panniantong | 100 | 112.3k | 8d ago | CLAUDE.md |
| rufloby ruvnet | 100 | 81.9k | today | CLAUDE.md |
| headroomby headroomlabs-ai | 100 | 79.8k | today | CLAUDE.md |
| Claude-Code-Game-Studiosby Donchitos | 100 | 39.7k | 7d ago | CLAUDE.md |
Frequently asked questions
- How do I install Technical Documentation Engine?
- Run
npx skills add LeoYeAI/openclaw-master-skills --skill "Technical Documentation Engine". The install tabs above show the steps for each supported agent. - Which AI agents does Technical Documentation Engine work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is Technical Documentation Engine safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 98/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is Technical Documentation Engine still maintained?
- The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
Skill content
View source on GitHubname: Technical Documentation Engine description: Complete technical documentation system — from planning through maintenance. Covers READMEs, API docs, guides, architecture docs, runbooks, and developer portals. Includes templates, quality scoring, and automation. metadata: category: writing skills: ["documentation", "technical-writing", "api-docs", "readme", "devdocs", "runbooks"]
Technical Documentation Engine
You are a technical documentation expert. You create, review, and maintain documentation that developers actually read and trust. Every document has a purpose, an audience, and a shelf life.
Phase 1 — Documentation Audit
Before writing anything, assess what exists.
Audit Checklist
Run through the codebase or project and score each area (0-3):
- 0 = Missing entirely
- 1 = Exists but outdated/wrong
- 2 = Exists, mostly correct, gaps
- 3 = Complete, current, useful
audit:
project: "[name]"
date: "YYYY-MM-DD"
scores:
readme: 0 # Root README with install + quickstart
getting_started: 0 # Tutorial for first-time users
api_reference: 0 # Every endpoint/function documented
architecture: 0 # System design, data flow, decisions
guides: 0 # Task-oriented how-tos
runbooks: 0 # Operational procedures
contributing: 0 # Dev setup, PR process, style guide
changelog: 0 # Version history with migration notes
troubleshooting: 0 # Common errors and solutions
deployment: 0 # How to deploy, environments, config
total: 0 # out of 30
grade: "F" # A(27-30) B(22-26) C(17-21) D(12-16) F(<12)
priority_gaps:
- "[highest impact missing doc]"
- "[second priority]"
- "[third priority]"
estimated_effort: "[hours to reach grade B]"
Priority Rules
- README always first — it's the front door
- Getting Started second — converts visitors to users
- API Reference third — retains users
- Everything else based on team pain points
Phase 2 — Document Types & Templates
2.1 README Template
# [Project Name]
[One sentence: what it does and who it's for.]
[Optional: badge row — max 4 badges: build, coverage, version, license]
## Quick Start
\`\`\`bash
# Install
[single copy-paste command]
# Run
[minimal command to see it work]
\`\`\`
Expected output:
\`\`\`
[what they should see]
\`\`\`
## What It Does
[3-5 bullet points of key capabilities. Not features — outcomes.]
- [Outcome 1 — what problem it solves]
- [Outcome 2]
- [Outcome 3]
## Installation
### Prerequisites
- [Runtime] v[X]+
- [Dependency] (optional, for [feature])
### Install
\`\`\`bash
[package manager install command with pinned version]
\`\`\`
### Configuration
\`\`\`bash
# Required
export API_KEY="your-key" # Get one at [URL]
# Optional
export LOG_LEVEL="info" # debug | info | warn | error
\`\`\`
## Usage
### [Primary Use Case]
\`\`\`[language]
[Complete, runnable example — imports through output]
\`\`\`
### [Secondary Use Case]
\`\`\`[language]
[Another complete example]
\`\`\`
## Documentation
- [Getting Started Guide](docs/getting-started.md)
- [API Reference](docs/api.md)
- [Configuration](docs/config.md)
- [Troubleshooting](docs/troubleshooting.md)
## Contributing
See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup and PR guidelines.
## License
[License type] — see [LICENSE](LICENSE)
2.2 Getting Started Guide Template
# Getting Started with [Project]
This guide walks you through [what they'll accomplish] in about [X] minutes.
## Prerequisites
Before starting, you need:
- [ ] [Requirement 1] — [how to check: `command --version`]
- [ ] [Requirement 2] — [where to get it]
- [ ] [Account/API key] — [signup URL]
## Step 1: [First Action]
[Why this step matters — one sentence.]
\`\`\`bash
[exact command]
\`\`\`
You should see:
\`\`\`
[expected output]
\`\`\`
> **Troubleshooting:** If you see `[common error]`, [fix].
## Step 2: [Second Action]
[Context sentence.]
\`\`\`bash
[command]
\`\`\`
[Explain what happened and what to notice.]
## Step 3: [Third Action]
[Continue pattern...]
## What You Built
You now have [concrete outcome]. Here's what's running:
\`\`\`
[diagram or description of what they set up]
\`\`\`
## Next Steps
- [Immediate next thing to try](link)
- [Deeper topic to explore](link)
- [Reference docs for everything](link)
## Common Issues
| Symptom | Cause | Fix |
|---------|-------|-----|
| `[error message]` | [why it happens] | [what to do] |
| [behavior] | [cause] | [fix] |
2.3 API Reference Template
For each endpoint or function:
## `[METHOD] /[path]` — [Short Description]
[One sentence explaining what this does and when to use it.]
**Authentication:** [type] required
**Rate Limit:** [X] requests per [period]
**Idempotent:** Yes/No
### Parameters
| Name | Location | Type | Required | Default | Description |
|------|----------|------|----------|---------|-------------|
| `id` | path | string | ✅ | — | [what it identifies] |
| `limit` | query | integer | — | 20 | [what it controls, valid range] |
| `filter` | query | string | — | — | [format, allowed values] |
### Request Body
\`\`\`json
{
"name": "Example", // Required. [constraints]
"email": "a@b.com", // Required. Must be valid email.
"settings": { // Optional. Defaults shown.
"notify": true,
"timezone": "UTC" // IANA timezone string
}
}
\`\`\`
### Response — `200 OK`
\`\`\`json
{
"id": "usr_abc123",
"name": "Example",
"email": "a@b.com",
"created_at": "2025-01-15T10:30:00Z",
"settings": {
"notify": true,
"timezone": "UTC"
}
}
\`\`\`
### Error Responses
| Status | Code | Description | Fix |
|--------|------|-------------|-----|
| 400 | `invalid_email` | Email format invalid | Check email format |
| 404 | `not_found` | Resource doesn't exist | Verify ID |
| 409 | `duplicate` | Email already registered | Use different email or update existing |
| 429 | `rate_limited` | Too many requests | Wait [X] seconds, implement backoff |
### Example
\`\`\`bash
curl -X POST https://api.example.com/v1/users \
-H "Authorization: Bearer $TOKEN" \
-H "Content-Type: application/json" \
-d '{
"name": "Jane Smith",
"email": "jane@example.com"
}'
\`\`\`
### Notes
- [Edge case or important behavior]
- [Pagination details if applicable]
- [Side effects: "Also sends welcome email"]
2.4 Architecture Document Template
# [System/Feature] Architecture
**Status:** [Draft | Proposed | Accepted | Superseded by [link]]
**Author:** [name]
**Date:** YYYY-MM-DD
**Reviewers:** [names]
## Context
[Why does this document exist? What problem or decision prompted it?]
## Requirements
### Must Have
- [Requirement with measurable criteria]
- [e.g., "Handle 10K requests/second with p99 < 200ms"]
### Nice to Have
- [Non-critical requirements]
### Non-Goals
- [Explicitly out of scope — prevents scope creep]
## Architecture Overview
\`\`\`
[ASCII diagram of components and data flow]
┌──────────┐ ┌──────────┐ ┌──────────┐
│ Client │────▶│ API │────▶│ DB │
└──────────┘ │ Gateway │ └──────────┘
└────┬─────┘
│
┌────▼─────┐
│ Queue │
└──────────┘
\`\`\`
## Components
### [Component 1]
- **Purpose:** [what it does]
- **Technology:** [stack choices]
- **Scaling:** [how it handles load]
- **Data:** [what it stores/processes]
### [Component 2]
[Same structure...]
## Data Flow
1. [Step 1: what happens first]
2. [Step 2: where data goes next]
3. [Step 3: processing/storage]
4. [Step 4: response path]
## Key Decisions
### Decision 1: [Choice Made]
- **Options considered:** [A, B, C]
- **Chosen:** [B]
- **Rationale:** [why — performance? simplicity? team expertise?]
- **Trade-offs:** [what we gave up]
- **Revisit when:** [conditions that would change this decision]
### Decision 2: [Choice Made]
[Same structure...]
## Failure Modes
| Failure | Impact | Detection | Recovery |
|---------|--------|-----------|----------|
| [DB down] | [partial outage] | [health check] | [failover to replica] |
| [Queue full] | [delayed processing] | [queue depth alert] | [auto-scale consumers] |
## Security Considerations
- [Authentication approach]
- [Data encryption (at rest, in transit)]
- [Access control model]
- [Sensitive data handling]
## Operational Concerns
- **Monitoring:** [key metrics to watch]
- **Alerts:** [what triggers pages]
- **Deployment:** [rollout strategy]
- **Rollback:** [how to revert]
## Future Considerations
- [Known limitations that will need addressing]
- [Scaling bottleneck predictions]
- [Migration paths if assumptions change]
2.5 Runbook Template
# Runbook: [Procedure Name]
**Severity:** P[0-3]
**Estimated Time:** [X] minutes
**Last Tested:** YYYY-MM-DD
**Owner:** [team/person]
## When to Use
[Trigger condition — what alert/symptom/request initiates this.]
## Prerequisites
- [ ] Access to [system/dashboard]
- [ ] [Tool] installed: `which [tool]`
- [ ] Permissions: [what role/access needed]
## Steps
### 1. Assess
\`\`\`bash
# Check current state
[diagnostic command]
\`\`\`
**Expected:** [what healthy looks like]
**If unhealthy:** [what you'll see instead]
### 2. Mitigate
\`\`\`bash
# Immediate action to reduce impact
[mitigation command]
\`\`\`
**Verify mitigation:**
\`\`\`bash
[verification command]
\`\`\`
### 3. Fix
\`\`\`bash
# Root cause fix
[fix command]
\`\`\`
### 4. Verify
\`\`\`bash
# Confirm resolution
[check command]
\`\`\`
**Success criteria:**
- [ ] [Metric] returned to normal
- [ ] [Service] responding
- [ ] [Alert] cleared
### 5. Post-Incident
- [ ] Update incident channel with resolution
- [ ] Schedule post-mortem if P0/P1
- [ ] File ticket for permanent fix if this was a workaround
- [ ] Update this runbook if steps changed
## Escalation
| Condition | Escalate To | How |
|-----------|-------------|-----|
| [Step 2 doesn't work after X min] | [team] | [channel/page] |
| [Data loss suspected] | [team + management] | [channel] |
## Rollback
If the fix makes things worse:
\`\`\`bash
[rollback command]
\`\`\`
## History
| Date | Who | What | Outcome |
|------|-----|------|---------|
| YYYY-MM-DD | [name] | [what happened] | [resolved/escalated] |
2.6 CONTRIBUTING.md Template
# Contributing to [Project]
## Development Setup
\`\`\`bash
# Clone and install
git clone [repo-url]
cd [project]
[install dependencies command]
# Verify setup
[test command]
\`\`\`
**Expected:** [X] tests pass, [Y] seconds.
## Making Changes
1. Create a branch: `git checkout -b [type]/[description]`
- Types: `feat`, `fix`, `docs`, `refactor`, `test`
2. Make your changes
3. Run tests: `[test command]`
4. Run linter: `[lint command]`
5. Commit using conventional commits:
\`\`\`
feat(scope): add user search endpoint
fix(auth): handle expired refresh tokens
docs: update API rate limit section
\`\`\`
## Pull Request Process
1. Fill out the PR template completely
2. Ensure CI passes (tests + lint + build)
3. Request review from [team/person]
4. Address feedback — don't force-push during review
5. Squash merge when approved
## Code Style
- [Link to style guide or key rules]
- [Formatting tool]: runs automatically on commit
- [Naming conventions]
- [File organization rules]
## Testing
- Unit tests for all new functions
- Integration tests for API endpoints
- Test file naming: `[file].test.[ext]`
- Minimum coverage: [X]%
## Architecture Decisions
Significant design changes need an ADR (Architecture Decision Record).
Template: `docs/adr/template.md`
## Getting Help
- Questions: [channel/forum]
- Bugs: [issue tracker]
- Security: [email — NOT public issues]
2.7 Changelog Template
# Changelog
All notable changes follow [Semantic Versioning](https://semver.org/).
## [Unreleased]
### Added
- [New feature with
Truncated for display — read the full file on GitHub.
Related Skills
Agent-Reach
112.3kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.
ruflo
81.9k🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
headroom
79.8kCompress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Claude-Code-Game-Studios
39.7kTurn Claude Code into a full game dev studio — 49 AI agents, 72 workflow skills, and a complete coordination system mirroring real studio hierarchy.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
