/doc-search

name: "doc-search"
description: "Search project documentation — ADRs, wiki entries, conventions via ripgrep, qmd, fff, and ctx"
license: "MIT"
compatibility: "cline, claude, opencode, amp, codex, gemini, cursor, pi"
hint: "Use when you need to find existing documentation before writing new docs"
user-invocable: true

Documentation Search

When to Use

Use this skill when:

• Starting work on a feature that may have existing decisions or ADRs
• Need to understand project conventions or patterns
• Looking for past design discussions or trade-off analyses
• Want to find relevant wiki entries or knowledge base articles
• Need to understand how existing documentation is structured
• Planning to write documentation and want to match existing style

What It Does

Helps you find and navigate existing project documentation using available tools (grep, qmd, fff, ctx). Documentation is often scattered across multiple locations — this skill provides a systematic approach to find what you need.

Where Documentation Lives

This project stores documentation in several locations:

| Location | Content | Best For | |----------|---------|----------| | `docs/` | User-facing guides (quick-start, tutorials) | Getting started, feature guides | | `ADRs` via `configs/adr/*` | Architecture Decision Records | Why decisions were made | | `wiki/` | LLM wiki — entities, concepts, log | Knowledge base, cross-references | | `MEMORY.md` | Durable project learnings and gotchas | Known issues, conventions | | `skills/*/SKILL.md` | Agent skill definitions | Tool capabilities | | `configs/*.md` | Tool-specific documentation | Per-tool behavior | | `AGENTS.md` | Agent instructions and guidelines | Development workflow | | qmd knowledge base | Indexed project knowledge | Searchable, AI-powered retrieval |

How to Search

Step 1: Find Relevant Documents

Use `fff` to locate documentation files:

fff "*.md" docs/         # All documentation files
fff "*adr*"              # Architecture Decision Records
fff "*auth*" docs/       # Auth-related documentation
fff "*wiki*"             # Wiki entries

Use `rg` (ripgrep) to search documentation content:

rg "decision" docs/                   # Find decisions in docs
rg "ADR-0" . --glob "*.md"           # Find ADR references
rg "rate.limiting" --glob "*.md"     # Find docs about rate limiting

Step 2: Query Knowledge Base

Use `qmd` to search durable project knowledge:

qmd search "authentication decisions"     # Find related knowledge
qmd query "What architecture exists for X?"  # Get structured answers
qmd get ADR-001                           # Get a specific ADR

The qmd knowledge base indexes project learnings, ADRs, conventions, and gotchas that persist across agent sessions.

Step 3: Search Past Sessions

Use `ctx` to find previous discussions about documentation:

ctx search "documentation" "decision"       # Past doc discussions
ctx search "ADR" "architecture" path/docs/  # Past ADR discussions
ctx search "convention" "pattern"            # Past convention discussions

Step 4: Explore by Pattern

Project documentation follows consistent patterns:

**Architecture Decision Records (ADRs)**:

# Find all ADRs
ls -la docs/adr/
# Search ADR content
rg "decision" docs/adr/

**Wiki entries**:

# Browse wiki structure
ls -la wiki/wiki/entities/
ls -la wiki/wiki/concepts/
# Search wiki content
rg "topic" wiki/wiki/ --glob "*.md"

**Agent skills**:

# Find skill documentation
rg "what.*does" skills/*/SKILL.md
# Find skills by category
rg "compatibility:.*auth" skills/*/SKILL.md

Understanding Documentation Style

Before writing new documentation, study existing examples:

1. **Pick a reference**: Find an existing doc on a similar topic 2. **Analyze structure**: Note heading levels, code blocks, tables 3. **Check tone**: Is it formal, conversational, or technical? 4. **Match conventions**: Use the same formatting patterns

Example: If you need to write an ADR, read an existing ADR first:

fff "*adr*.md"   # Find existing ADRs
cat docs/adr/001-some-decision.md  # Read as reference

Documentation Discovery Workflow

Before writing:
1. Search existing docs for related content
2. Check qmd for existing knowledge
3. Search ctx for past discussions
4. Read existing docs for style reference

During writing:
5. Link to relevant ADRs and decisions
6. Reference existing conventions
7. Cross-link related documentation

After writing:
8. Add to wiki or qmd knowledge base
9. Reference from relevant agent instructions
10. Update docs-update skill if patterns changed

Integration with Other Skills

• **docs-update**: Use doc-search first to find what exists before updating
• **context-discovery**: Documentation search is part of context discovery
• **implementation-logger**: Extract learnings into documentation
• **qmd-knowledge**: Add new knowledge to durable storage
• **llm-wiki**: Build and maintain wiki entries from findings

Tips

• **Search before writing**: Always check if documentation already exists
• **Follow existing patterns**: Match the style of existing docs
• **Cross-link**: Reference ADRs, wiki entries, and related docs
• **Update qmd**: After finding useful documentation, index it in qmd
• **Use `rg` over `grep`**: ripgrep is faster and respects .gitignore
• **Check wiki/ first**: The LLM wiki is designed for discoverability