---
skill_name: [TECH]-docs
description: Complete [Technology] documentation reference including guides, samples, and API specifications. Use this skill to look up [Technology] concepts, APIs, syntax, and best practices. Cross-reference with [TECH]-patterns for idiomatic usage.
trigger: When working with [Technology], or when needing comprehensive [Technology] documentation
keywords: [tech], documentation, guides, samples, [key-feature-1], [key-feature-2]
version: 0.1.0
---

# [Technology] Documentation Reference

This skill provides complete access to [Technology] documentation, organized for quick discovery via grep patterns and cross-references to application-specific skills.

## Quick Reference Guide

**Finding Documentation:**
```bash
# Search for specific concepts
rg -i "[concept]" references/guides/
rg -i "[feature]" references/guides/

# Find code examples
rg -l "[pattern]" references/samples/ | head -5
rg -l "[language-specific]" references/samples/ | head -5

# Find specific API patterns
rg "[function-name]" references/api-reference/
rg "[class-name]" references/api-reference/
```

## Documentation Structure

### Guides (`references/guides/`)

Comprehensive guides covering:
- **Getting Started**: Initial setup, quickstarts, tutorials
- **Core Concepts**: Fundamental principles, architecture
- **Best Practices**: Recommended patterns, optimization
- **Advanced Topics**: Deep dives, edge cases
- **Troubleshooting**: Common issues, debugging

**Quick grep patterns for guides:**
```bash
# Getting started
rg "getting started\|quickstart" references/guides/ -i -l | head -5

# Core concepts
rg "[core-concept-1]\|[core-concept-2]" references/guides/ -i -l

# Best practices
rg "best practice\|recommended" references/guides/ -i -l

# Troubleshooting
rg "troubleshoot\|debug\|error" references/guides/ -i -l
```

### Samples (`references/samples/`)

Code samples covering:
- **Basic Examples**: Hello world, simple usage
- **Common Patterns**: Typical workflows
- **Integration Examples**: Third-party tools
- **Advanced Examples**: Complex scenarios

**Quick grep patterns for samples:**
```bash
# [Language] examples
rg "import\|require" references/samples/ -l | head -5

# Specific patterns
rg "[pattern-name]" references/samples/ -l

# Integration examples
rg "[integration-keyword]" references/samples/ -A5
```

### API Reference (`references/api-reference/`)

Complete API specification covering:
- Functions and methods
- Classes and interfaces
- Configuration options
- Return types and parameters

**Quick grep patterns for API:**
```bash
# Function reference
rg "function [function-name]" references/api-reference/
rg "def [function-name]" references/api-reference/

# Class reference
rg "class [ClassName]" references/api-reference/

# Configuration
rg "config\|option" references/api-reference/ -i -l
```

## Cross-References to Application Skills

### [tech]-patterns
**Use this skill for**: Basic patterns, common workflows, [framework] integration

**When to cross-reference:**
- Implementing basic features
- Following common patterns
- [Framework]-specific integration

### [tech]-advanced
**Use this skill for**: Advanced patterns, optimization, performance tuning

**When to cross-reference:**
- Performance optimization
- Complex architectures
- Edge cases and gotchas

### [tech]-integration
**Use this skill for**: Third-party integrations, [ecosystem] patterns

**When to cross-reference:**
- Integrating with [tool/framework]
- Multi-service architectures
- Cross-platform development

## Common Lookup Patterns

### Finding Setup Instructions
```bash
# Installation
rg "install\|setup" references/guides/ -i -l | head -3

# Configuration
rg "config\|configure" references/guides/ -i -l
```

### Finding API Documentation
```bash
# Specific function
rg "[FunctionName]" references/api-reference/ -A10

# Specific class
rg "class [ClassName]" references/api-reference/ -A20
```

### Finding Examples
```bash
# Working code examples
rg "[language-import-keyword]" references/samples/ -l | head -10

# Specific pattern examples
rg "[pattern]" references/samples/ -A15
```

### Finding Troubleshooting Info
```bash
# Error messages
rg "[error-text]" references/guides/ -i -A5

# Common issues
rg "troubleshoot\|common issue" references/guides/ -i -l
```

## Documentation Organization

```
references/
├── guides/          # Complete guides ([N] docs)
├── samples/         # Code samples ([N] docs)
├── api-reference/   # API specifications ([N] docs)
└── resources/       # Additional resources ([N] docs)
```

**Note**: All categories contain full markdown documentation scraped from official sources.

## Progressive Documentation Discovery

1. **Start with [tech]-docs** for concept understanding
2. **Cross-reference application skills** for practical patterns
3. **Use grep patterns** for quick code discovery
4. **Check samples/** for working code examples
5. **Consult guides/** for comprehensive explanations

## Troubleshooting Reference

**Common issues and where to look:**

- **Setup errors**: `references/guides/getting-started.md`, `references/guides/installation.md`
- **API errors**: `references/api-reference/`, `references/guides/error-handling.md`
- **Performance issues**: `references/guides/optimization.md`, `references/guides/performance.md`
- **Configuration errors**: `references/guides/configuration.md`, `references/api-reference/config.md`
- **Integration issues**: `references/guides/integration.md`, `references/samples/integrations/`

## Maintenance Notes

**Scraping status:**
- ✅ Guides ([N] docs, [SIZE])
- ✅ Samples ([N] docs, [SIZE])
- ✅ API reference ([N] docs, [SIZE])
- ✅ Resources ([N] docs, [SIZE])

**Update frequency**: Documentation should be re-scraped quarterly to capture updates from official sources.

**Grep tips:**
- Use `-i` for case-insensitive search
- Use `-l` to list files only (faster discovery)
- Use `-A5` to show 5 lines after match for context
- Use `head -5` to limit results for large result sets

---

## Template Instructions

**Replace the following placeholders:**

- `[TECH]` → Technology abbreviation (e.g., "postgres", "react")
- `[Technology]` → Full technology name (e.g., "PostgreSQL", "React")
- `[tech]` → Lowercase name (e.g., "postgres", "react")
- `[concept]` → Core concepts (e.g., "components", "hooks", "transactions")
- `[feature]` → Key features (e.g., "state management", "routing")
- `[pattern]` → Common patterns (e.g., "async/await", "dependency injection")
- `[function-name]` → Example function (e.g., "useState", "createConnection")
- `[class-name]` → Example class (e.g., "Component", "Client")
- `[ClassName]` → PascalCase class name
- `[language]` → Programming language (e.g., "JavaScript", "Python")
- `[framework]` → Related framework (e.g., "Next.js", "Django")
- `[tool/framework]` → Integration target
- `[ecosystem]` → Technology ecosystem
- `[N]` → Actual count (e.g., "328")
- `[SIZE]` → Actual size (e.g., "2.5MB")
- `[core-concept-1]`, `[core-concept-2]` → Replace with actual concepts
- `[key-feature-1]`, `[key-feature-2]` → Replace with key features
- `[integration-keyword]` → Integration-specific terms
- `[language-import-keyword]` → Language-specific imports (e.g., "import", "require", "from")
- `[language-specific]` → Language-specific patterns
- `[error-text]` → Common error messages

**Directory setup:**

```bash
mkdir -p references/{guides,samples,api-reference,resources}
```

**Scraping:**

Use the bundled `scripts/firecrawl-scraper.sh` or `scripts/url-extractor.sh` to populate `references/`.

**Validation:**

1. Test all grep patterns return results
2. Verify relative paths to application skills work
3. Check skill file is < 500 lines
4. Ensure cross-references are bidirectional

**Next steps:**

1. Create application skills using `application-skill-template.md`
2. Create `plugin.json` using `plugin-template.json`
3. Test composition (load docs + 2 app skills)
4. Validate grep patterns work from application skills
