playbooks

home / skills / williamzujkowski / standards / documentation

documentation skill

/skills/content/documentation

This skill helps you apply documented standards to create secure, maintainable, and well-tested content across projects.

npx playbooks add skill williamzujkowski/standards --skill documentation

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

Files (4)
SKILL.md
1.9 KB
---
name: documentation
description: Documentation standards for documentation in Content environments. Covers
---

# Documentation

> **Quick Navigation:**
> Level 1: [Quick Start](#level-1-quick-start) (5 min) → Level 2: [Implementation](#level-2-implementation) (30 min) → Level 3: [Mastery](#level-3-mastery-resources) (Extended)

---

## Level 1: Quick Start

### Core Principles

1. **Best Practices**: Follow industry-standard patterns for content
2. **Security First**: Implement secure defaults and validate all inputs
3. **Maintainability**: Write clean, documented, testable code
4. **Performance**: Optimize for common use cases

### Essential Checklist

- [ ] Follow established patterns for content
- [ ] Implement proper error handling
- [ ] Add comprehensive logging
- [ ] Write unit and integration tests
- [ ] Document public interfaces

### Quick Links to Level 2

- [Core Concepts](#core-concepts)
- [Implementation Patterns](#implementation-patterns)
- [Common Pitfalls](#common-pitfalls)

---

## Level 2: Implementation

### Core Concepts

This skill covers essential practices for content.

**Key areas include:**

- Architecture patterns
- Implementation best practices
- Testing strategies
- Performance optimization

### Implementation Patterns

Apply these patterns when working with content:

1. **Pattern Selection**: Choose appropriate patterns for your use case
2. **Error Handling**: Implement comprehensive error recovery
3. **Monitoring**: Add observability hooks for production

### Common Pitfalls

Avoid these common mistakes:

- Skipping validation of inputs
- Ignoring edge cases
- Missing test coverage
- Poor documentation

---

## Level 3: Mastery Resources

### Reference Materials

- [Related Standards](../../docs/standards/)
- [Best Practices Guide](../../docs/guides/)

### Templates

See the `templates/` directory for starter configurations.

### External Resources

Consult official documentation and community best practices for content.

Overview

This skill defines documentation standards for content environments, focused on fast project onboarding and consistent, production-ready docs. It packages battle-tested patterns from real LLM software systems to help teams start projects correctly and maintain high-quality documentation over time.

How this skill works

The skill inspects documentation structure, required sections, and implementation patterns for content-related projects. It checks for secure defaults, validation guidance, testing and logging recommendations, and provides templates and links for deeper mastery. Outputs are concrete checklists and actionable patterns to align docs with engineering and security expectations.

When to use it

  • Starting a new content or LLM-related project and you need a runnable documentation baseline
  • Standardizing docs across multiple repositories to ensure consistent interfaces and security guidance
  • Onboarding new engineers who need a quick reference to core concepts, patterns, and implementation checks
  • Auditing existing documentation for gaps in validation, testing, observability, or error handling
  • Preparing public or internal interfaces for production readiness and compliance reviews

Best practices

  • Provide a Quick Start (5 min) and linked deeper sections for implementation and mastery
  • Enforce secure defaults and explicit input validation in docs and code examples
  • Include an essential checklist: error handling, logging, tests, and public interface docs
  • Document architecture patterns, testing strategies, and monitoring hooks for production
  • Keep templates and reference materials versioned and easy to reuse across projects

Example use cases

  • Bootstrapping a new Python-based LLM project with a 30-second start and documented patterns
  • Evaluating repository docs to ensure test coverage, observability, and security guidance are present
  • Creating a team-wide documentation template that includes quick start, implementation, and mastery levels
  • Producing compliance-ready documentation that highlights validation and error recovery practices
  • Teaching new hires core content engineering concepts using the three-level learning path

FAQ

How long does it take to get started using these documentation standards?

You can apply the Quick Start baseline in about five minutes and reach a complete implementation checklist in roughly 30 minutes.

Are these standards specific to Python or usable elsewhere?

While examples target Python and LLM workflows, the core principles—security, maintainability, testing, and performance—are language-agnostic and applicable across ecosystems.