home / skills / lerianstudio / ring / using-tw-team

This skill helps you generate precise API and conceptual documentation by coordinating ring:using-tw-team specialists to follow established standards.

npx playbooks add skill lerianstudio/ring --skill using-tw-team

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

Files (1)
SKILL.md
3.8 KB
---
name: ring:using-tw-team
description: |
  Technical writing specialists for functional and API documentation. Dispatch when
  you need to create guides, conceptual docs, or API references following established
  documentation standards.

trigger: |
  - Need to write functional documentation (guides, conceptual docs, tutorials)
  - Need to write API reference documentation
  - Need to review existing documentation quality
  - Writing or updating product documentation

skip_when: |
  - Writing code → use dev-team agents
  - Writing plans → use pm-team agents
  - General code review → use default plugin reviewers

related:
  similar: [ring:using-ring, ring:using-dev-team]
---

# Using Ring Technical Writing Specialists

The ring-tw-team plugin provides specialized agents for technical documentation. Use them via `Task tool with subagent_type:`.

**Remember:** Follow the **ORCHESTRATOR principle** from `ring:using-ring`. Dispatch agents to handle documentation tasks; don't write complex documentation directly.

## 3 Documentation Specialists

| Agent | Specialization | Use When |
|-------|---------------|----------|
| `ring:functional-writer` | Conceptual docs, guides, tutorials, best practices, workflows | Writing product guides, tutorials, "how to" content |
| `ring:api-writer` | REST API reference, endpoints, schemas, errors, field descriptions | Documenting API endpoints, request/response examples |
| `ring:docs-reviewer` | Voice/tone, structure, completeness, clarity, accuracy | Reviewing drafts, pre-publication quality check |

---

## Documentation Standards Summary

### Voice and Tone
- **Assertive, but never arrogant** – Say what needs to be said, clearly
- **Encouraging and empowering** – Guide users through complexity
- **Tech-savvy, but human** – Use technical terms when needed, prioritize clarity
- **Humble and open** – Confident but always learning

### Capitalization
- **Sentence case** for all headings and titles
- Only first letter and proper nouns capitalized
- ✅ "Getting started with the API"
- ❌ "Getting Started With The API"

### Structure Patterns
1. Lead with clear definition paragraph
2. Use bullet points for key characteristics
3. Separate sections with `---` dividers
4. Include info boxes and warnings where needed
5. Link to related API reference
6. Add code examples for technical topics

---

## Dispatching Specialists

**Parallel dispatch** for comprehensive documentation (single message, multiple Tasks):

```
Task #1: functional-writer (write the guide)
Task #2: api-writer (write API reference)
(Both run in parallel)

Then:
Task #3: docs-reviewer (review both)
```

---

## Available in This Plugin

**Agents:** functional-writer, api-writer, docs-reviewer

**Skills:**
- using-tw-team: Plugin introduction
- writing-functional-docs: Functional doc patterns
- writing-api-docs: API reference patterns
- documentation-structure: Hierarchy and organization
- voice-and-tone: Voice guidelines
- documentation-review: Quality checklist
- api-field-descriptions: Field description patterns

**Commands:**
- /write-guide: Start functional guide
- /write-api: Start API documentation
- /review-docs: Review existing docs

---

## Integration with Other Plugins

| Plugin | Use For |
|--------|---------|
| ring:using-ring (default) | ORCHESTRATOR principle |
| ring:using-dev-team | Developer agents for technical accuracy |
| ring:using-pm-team | Pre-dev planning before documentation |

---

## ORCHESTRATOR Principle

- **You're the orchestrator** – Dispatch specialists, don't write directly
- **Let specialists apply standards** – They know voice, tone, structure
- **Combine with other plugins** – API writers + backend engineers for accuracy

> ✅ "I need documentation for the new feature. Let me dispatch functional-writer."
>
> ❌ "I'll manually write all the documentation myself."

Overview

This skill provides access to a team of technical writing specialists optimized for functional guides and API references. Dispatch the appropriate subagent to generate conceptual docs, endpoint references, or to perform review and quality checks. The team follows established documentation standards so outputs are consistent, clear, and publication-ready.

How this skill works

Invoke the Task tool with subagent_type set to one of three specialists: functional-writer, api-writer, or docs-reviewer. Functional writers produce guides, tutorials, and workflows; API writers produce endpoint specs, schemas, and examples; reviewers check voice, structure, and completeness. For full quality, dispatch writers in parallel and follow with a docs-reviewer pass as the orchestrator.

When to use it

  • Create product guides, tutorials, onboarding flows, or how-to content
  • Write REST API reference pages, schemas, request/response examples, and error docs
  • Perform pre-publication reviews for tone, structure, and accuracy
  • Enforce documentation standards across a release or feature batch
  • Combine with engineering agents to validate technical accuracy

Best practices

  • Always act as the orchestrator: dispatch specialists instead of writing complex docs yourself
  • Run functional-writer and api-writer in parallel when both guide and reference are needed, then run docs-reviewer
  • Follow the voice and tone rules: assertive, encouraging, tech-savvy but human
  • Use sentence case for headings and titles consistently
  • Include concise definition lead, bullet characteristics, code examples, and links to reference

Example use cases

  • New feature launch: parallel tasks create user guide and API reference, then review for publishing
  • API versioning: api-writer produces endpoint diffs, examples, and schema changes for release notes
  • Onboarding flow: functional-writer writes step-by-step tutorials with sample data and warnings
  • Pre-release QA: docs-reviewer audits drafts for clarity, completeness, and adherence to tone

FAQ

Which agent should I dispatch for a REST endpoint?

Dispatch ring:api-writer to produce endpoint descriptions, request/response examples, schema fields, and error details.

Can I run multiple agents at once?

Yes. Run functional-writer and api-writer in parallel for comprehensive docs, then dispatch docs-reviewer to audit both outputs.

What documentation standards are applied?

The team uses a clear lead definition, bullet key characteristics, sentence case headings, code examples where relevant, and the voice guidelines described above.