Write complete API documentation.
API name: [your API]
Endpoints: [list endpoints]
Authentication: [auth method]
Audience: [developer skill level]

Create API docs with:
- Overview and introduction
- Authentication guide
- Base URL and versioning
- Endpoint reference (all endpoints)
- Request/response examples (formatted)
- Parameters (required/optional)
- Error codes and handling
- Rate limits and quotas
- SDK examples (multiple languages)
- Quick start tutorial
- Best practices

Developer-friendly API docs.

API: [paste details]

Write getting started guide for product.
Product: [your software/tool]
User type: [beginner/intermediate]
Time to value: [how quickly they succeed]
Key features: [essential functionality]

Create quick start with:
- What the product does (overview)
- Prerequisites (requirements)
- Installation/setup (step-by-step)
- First successful use (quick win)
- Next steps (what to explore)
- Common issues (troubleshooting)
- Where to get help (support resources)

Fast path to success.

Product: [paste details]

Write comprehensive user manual.
Product: [your product]
Features: [all functionality]
Audience: [user profile]
Depth: [basic/advanced/complete]

Create user manual with:
- Product overview (what it does)
- Interface walkthrough (UI elements)
- Feature documentation (how each works)
- Common workflows (typical tasks)
- Advanced features (power user guide)
- Settings and configuration
- Keyboard shortcuts
- FAQ section
- Troubleshooting guide
- Glossary of terms

Complete reference manual.

Product: [paste details]

Write installation documentation.
Software: [your application]
Platforms: [OS/environments]
Requirements: [system specs]
Complexity: [installation difficulty]

Document installation:
- System requirements (minimum/recommended)
- Pre-installation checklist
- Installation steps (detailed)
- Platform-specific instructions
- Configuration after install
- Verification steps (test it works)
- Common installation issues
- Uninstallation process
- Upgrade path (from old versions)

Error-free installation.

Software: [paste details]

Create troubleshooting documentation.
Product: [your product]
Common issues: [known problems]
Support data: [frequent tickets]

Build troubleshooting guide:
- Problem categories (organize by type)
- Symptom descriptions (what user sees)
- Diagnostic steps (how to identify cause)
- Solutions (step-by-step fixes)
- Prevention tips (avoid future issues)
- When to contact support (escalation)
- Error code reference
- System logs interpretation

Self-service problem resolution.

Product: [paste details]

Write code documentation and comments.
Code: [paste code or describe function]
Language: [programming language]
Audience: [other developers]
Purpose: [what code does]

Document code with:
- Function/class purpose (what it does)
- Parameters (inputs explained)
- Return values (outputs explained)
- Usage examples (how to call)
- Edge cases (special scenarios)
- Error handling (exceptions)
- Dependencies (requirements)
- Performance notes (optimization)
- Version history (changes)

Maintainable code documentation.

Code: [paste code]

Document system architecture.
System: [your application/platform]
Components: [major parts]
Scale: [users/load]
Audience: [engineers/architects]

Create architecture docs:
- System overview (high-level)
- Architecture diagram description
- Component breakdown (each part)
- Data flow (how information moves)
- Integration points (external systems)
- Technology stack (tools/frameworks)
- Scalability approach (how it scales)
- Security architecture (protection)
- Deployment architecture (infrastructure)

Technical system understanding.

System: [paste details]

Write configuration documentation.
Product: [your software]
Settings: [configurable options]
Use cases: [different configurations]
Audience: [admin/power users]

Document configuration:
- Configuration overview (what's configurable)
- Settings reference (all options)
- Recommended configurations (best practices)
- Use case configurations (scenarios)
- Environment-specific settings (dev/staging/prod)
- Performance tuning (optimization)
- Security settings (hardening)
- Configuration examples (templates)
- Troubleshooting config issues

Optimal configuration guidance.

Product: [paste details]

Create migration/upgrade documentation.
From version: [old version]
To version: [new version]
Breaking changes: [what breaks]
Timeline: [migration duration]

Write migration guide:
- Migration overview (why upgrade)
- Breaking changes (what's different)
- Pre-migration checklist (backup/prep)
- Migration steps (detailed process)
- Data migration (if applicable)
- Testing after migration (verification)
- Rollback procedure (if issues)
- Post-migration optimization
- Common migration issues

Safe version transitions.

Migration: [paste details]

Write integration documentation.
Your product: [your system]
Integrating with: [other systems]
Integration type: [API/webhook/native]
Use case: [why integrate]

Document integration:
- Integration overview (what it enables)
- Prerequisites (requirements)
- Authentication setup (credentials)
- Integration steps (how to connect)
- Configuration options (settings)
- Data mapping (field matching)
- Testing integration (verification)
- Webhook setup (if applicable)
- Error handling (troubleshooting)
- Use case examples

Seamless integrations.

Integration: [paste details]

Write security documentation.
System: [your product]
Security level: [compliance requirements]
Audience: [security teams/auditors]

Document security:
- Security overview (approach)
- Authentication mechanisms (how users authenticate)
- Authorization model (permissions)
- Data encryption (at rest/in transit)
- Security best practices (recommendations)
- Compliance certifications (standards met)
- Vulnerability reporting (responsible disclosure)
- Security audit logs (what's logged)
- Incident response (breach protocol)

Security transparency.

System: [paste details]

Write changelog/release notes.
Version: [release number]
Changes: [what's new/fixed]
Date: [release date]
Impact: [who it affects]

Create changelog entry:
- Version number and date
- New features (what's added)
- Improvements (what's better)
- Bug fixes (what's resolved)
- Breaking changes (what breaks)
- Deprecations (what's removed)
- Migration notes (how to adapt)
- Known issues (current problems)
- Contributors (who helped)

Track product evolution.

Version: [paste details]

Document command-line interface.
CLI tool: [your command-line tool]
Commands: [available commands]
Audience: [developer skill level]

Create CLI docs:
- Installation (getting the CLI)
- Basic usage (common commands)
- Command reference (all commands)
- Options and flags (parameters)
- Output formats (how it returns data)
- Configuration files (settings)
- Environment variables (what's available)
- Examples (common use cases)
- Chaining commands (advanced usage)

Terminal-friendly documentation.

CLI: [paste details]

Document database schema.
Database: [your database]
Tables: [main entities]
Relationships: [how they connect]
Audience: [developers/DBAs]

Create schema docs:
- Schema overview (database structure)
- Table descriptions (what each stores)
- Column definitions (field details)
- Relationships (foreign keys)
- Indexes (what's indexed)
- Constraints (rules/validations)
- Sample queries (common operations)
- Schema evolution (version history)
- Performance considerations

Database understanding.

Schema: [paste details]

Document complex workflow or process.
Workflow: [process name]
Steps: [sequence of actions]
Decision points: [branches in flow]
Stakeholders: [who's involved]

Create workflow docs:
- Workflow overview (purpose)
- Process diagram description
- Step-by-step breakdown (detailed)
- Decision points (when to branch)
- Role responsibilities (who does what)
- Timing (duration per step)
- Prerequisites (before starting)
- Success criteria (completion)
- Exception handling (edge cases)

Process clarity.

Workflow: [paste details]

Write plugin or extension documentation.
Plugin: [your extension]
Platform: [what it extends]
Features: [capabilities]
Audience: [plugin users]

Document plugin:
- Plugin overview (what it adds)
- Installation (how to add)
- Activation (how to enable)
- Configuration (settings)
- Features (what it can do)
- Usage examples (practical applications)
- Compatibility (versions supported)
- Known limitations (what it can't do)
- Troubleshooting (common issues)

Extension clarity.

Plugin: [paste details]

Write performance and optimization guide.
System: [your product]
Performance metrics: [key indicators]
Optimization areas: [what can be tuned]

Document performance:
- Performance overview (baseline metrics)
- Benchmarks (expected performance)
- Monitoring (how to measure)
- Optimization techniques (how to improve)
- Caching strategies (what to cache)
- Database optimization (query tuning)
- Resource limits (capacity planning)
- Scaling strategies (horizontal/vertical)
- Performance troubleshooting

Speed and efficiency.

System: [paste details]

Create deployment documentation.
Application: [your app]
Environment: [where it deploys]
Method: [deployment approach]
Complexity: [deployment difficulty]

Write deployment guide:
- Deployment overview (process)
- Prerequisites (requirements)
- Environment setup (infrastructure)
- Deployment steps (detailed)
- Configuration management (env variables)
- Database migrations (schema updates)
- Health checks (verification)
- Rollback procedure (if fails)
- Monitoring after deployment

Safe deployments.

Application: [paste details]

Write testing documentation.
System: [what to test]
Test types: [unit/integration/e2e]
Coverage: [what's tested]
Audience: [QA/developers]

Document testing:
- Testing strategy (approach)
- Test environment setup (requirements)
- Test case documentation (scenarios)
- How to run tests (execution)
- Expected results (what passes)
- Coverage reports (what's covered)
- Continuous integration (CI setup)
- Bug reporting (how to report)
- Testing best practices

Quality assurance.

System: [paste details]

Create backup and disaster recovery docs.
System: [your application]
Data: [what needs backup]
Recovery time: [RTO/RPO targets]

Document backup/recovery:
- Backup strategy (approach)
- What to backup (data/config)
- Backup frequency (schedule)
- Backup location (where stored)
- Backup verification (testing)
- Recovery procedures (step-by-step)
- Recovery time objectives (targets)
- Disaster scenarios (what-if)
- Testing recovery (validation)

Data protection.

System: [paste details]

Write administrator documentation.
Product: [your system]
Admin tasks: [common operations]
Audience: [system administrators]

Create admin guide:
- Admin console overview (interface)
- User management (add/remove/roles)
- Permission management (access control)
- System configuration (settings)
- Monitoring and alerts (observability)
- Maintenance tasks (routine operations)
- Backup management (data protection)
- Security administration (hardening)
- Troubleshooting (admin issues)

Administrative mastery.

Product: [paste details]

Write compliance documentation.
System: [your product]
Standards: [GDPR/HIPAA/SOC2/etc]
Audience: [compliance officers/auditors]

Document compliance:
- Compliance overview (certifications)
- Data handling (privacy practices)
- Audit logs (what's tracked)
- Access controls (who can access)
- Data retention (storage policies)
- Incident response (breach protocol)
- Vendor assessment (third-parties)
- Compliance controls (safeguards)
- Audit preparation (what auditors see)

Regulatory confidence.

System: [paste details]

Write SDK/library documentation.
SDK: [your software development kit]
Language: [programming language]
Features: [SDK capabilities]
Audience: [developers]

Create SDK docs:
- Installation (package manager)
- Initialization (setup code)
- Authentication (how to authenticate)
- Core methods (main functions)
- Code examples (practical usage)
- Error handling (exceptions)
- Best practices (recommendations)
- Advanced features (power usage)
- Reference (complete API)

Developer productivity.

SDK: [paste details]

Create technical glossary and reference.
Domain: [your field/product]
Terms: [technical terminology]
Audience: [who needs definitions]

Build glossary:
- Alphabetical term list
- Clear definitions (layman's terms)
- Technical definitions (precise)
- Examples (usage context)
- Related terms (connections)
- Acronyms expanded (full names)
- Common abbreviations
- Visual diagrams (if helpful)
- Cross-references (see also)

Shared vocabulary.

Domain: [paste details]

Write script for technical tutorial video.
Topic: [what to teach]
Duration: [video length]
Difficulty: [beginner/advanced]
Outcome: [what viewers achieve]

Create video script:
- Hook (first 10 seconds)
- Introduction (what they'll learn)
- Prerequisites (what they need)
- Step-by-step walkthrough (detailed)
- On-screen actions (what to show)
- Voiceover script (what to say)
- Visual callouts (highlight items)
- Common mistakes (what to avoid)
- Conclusion (recap and CTA)

Engaging video content.

Topic: [paste details]