home / skills / proffesor-for-testing / agentic-qe / technical-writing

technical-writing skill

/v3/assets/skills/technical-writing

This skill helps you craft clear, actionable technical writing from real experience, improving reader comprehension and practical takeaway.

npx playbooks add skill proffesor-for-testing/agentic-qe --skill technical-writing

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

Files (1)
SKILL.md
4.7 KB
---
name: technical-writing
description: "Write clear, engaging technical content from real experience. Use when writing blog posts, documentation, tutorials, or technical articles."
category: communication
priority: medium
tokenEstimate: 800
agents: [qe-quality-analyzer, qe-api-contract-validator]
implementation_status: optimized
optimization_version: 1.0
last_optimized: 2025-12-03
dependencies: []
quick_reference_card: true
tags: [writing, documentation, communication, blogs, tutorials]
---

# Technical Writing

<default_to_action>
When writing technical content:
1. LEAD with value (what will reader learn/gain?)
2. SHOW, don't tell (specific examples, code, numbers)
3. STRUCTURE for scanning (headers, bold, short paragraphs)
4. CUT ruthlessly (every sentence must earn its place)
5. BE honest about trade-offs

**Blog Post Structure:**
```markdown
# Title (specific promise)

## Opening (2-3 paragraphs)
- Hook: The problem or insight
- Context: Why this matters
- Promise: What they'll learn

## Body (3-5 sections)
- One clear idea per section
- Support with examples/code/data

## Closing
- Key takeaway (1-2 sentences)
- Action reader can take
```

**Before/After:**
❌ "We implemented a comprehensive testing strategy..."
✅ "We moved exploratory testing into sprint planning. QE now pairs with devs during story refinement."
</default_to_action>

## Quick Reference Card

### Core Principles

| Principle | Bad | Good |
|-----------|-----|------|
| **Lead with value** | "In today's landscape..." | "Here's how we cut bugs 60%" |
| **Show, don't tell** | "We improved testing" | "Bug detection: 12→47 per sprint" |
| **Be specific** | "Performance improved" | "Response time: 2.3s→180ms" |
| **Honest trade-offs** | "This approach is best" | "TDD slowed velocity 20%, reduced bugs 75%" |

### Words to Cut

| Kill | Reason |
|------|--------|
| basically, actually, probably | Hedge words |
| leverage, synergy, paradigm | Corporate speak |
| very, really, quite | Unnecessary qualifiers |
| it should be noted that | Just note it |

---

## Audience-Specific Writing

### For Developers
- Lead with code or concrete problem
- Show implementation details
- Discuss trade-offs and alternatives
- Link to repos or examples

### For QA/QE
- Start with testing challenge
- Show strategy, not just tools
- Include risk assessment
- Provide adaptable heuristics

### For Leadership
- Open with business impact
- Use metrics that matter
- Connect technical to outcomes
- Keep technical details concise

---

## Editing Checklist

Before publishing:
- [ ] Title promises something specific
- [ ] Opening hooks in 30 seconds
- [ ] Claims backed by examples
- [ ] All unnecessary words cut
- [ ] Code examples tested and correct
- [ ] Takeaway crystal clear
- [ ] Would send to respected colleague

---

## Example Transformations

**Before:**
"We decided to implement a more comprehensive testing strategy that would allow us to catch bugs earlier in the development lifecycle."

**After:**
"We moved exploratory testing into sprint planning. QE now pairs with devs during story refinement, identifying risks before code is written."

---

**Before:**
"The benefits of this approach are numerous and include improved quality, faster feedback loops, and better team collaboration."

**After:**
"Three outcomes: bugs found 2 days earlier on average, 30% fewer regression issues, and devs now ask QE for input during design."

---

## Agent Integration

```typescript
// Generate documentation from code
const docs = await Task("Generate Docs", {
  source: 'src/services/PaymentService.ts',
  format: 'markdown',
  includeExamples: true
}, "qe-quality-analyzer");

// Review documentation quality
const review = await Task("Review Docs", {
  files: ['README.md', 'docs/api.md'],
  checkClarity: true,
  checkCodeExamples: true
}, "qe-quality-analyzer");
```

---

## Agent Coordination Hints

### Memory Namespace
```
aqe/technical-writing/
├── generated-docs/*   - Auto-generated documentation
├── reviews/*          - Documentation review findings
└── templates/*        - Reusable doc templates
```

### Fleet Coordination
```typescript
const docsFleet = await FleetManager.coordinate({
  strategy: 'documentation',
  agents: [
    'qe-quality-analyzer',         // Generate and review
    'qe-api-contract-validator'    // API doc accuracy
  ],
  topology: 'sequential'
});
```

---

## Related Skills
- [bug-reporting-excellence](../bug-reporting-excellence/) - Technical bug writing
- [code-review-quality](../code-review-quality/) - Review documentation

---

## Remember

**You're not writing to impress.** You're writing to help people solve problems you've already solved. Be the colleague you wish you'd had.

**Write from experience.** Only write about what you've done in production. If exploring, say so.

Overview

This skill teaches how to write clear, engaging technical content grounded in real experience. It provides concrete structure, editing rules, and audience-specific guidance for blog posts, documentation, tutorials, and technical articles aimed at engineers and QA teams.

How this skill works

The skill inspects your draft or code and applies practical rules: lead with value, show concrete examples, structure for scanning, cut unnecessary words, and state trade-offs honestly. It can generate skeletons (title, opening, body sections, closing), transform vague prose into specific statements, and produce checklists and examples tied to real outcomes.

When to use it

  • Writing a blog post that must communicate a technical win or lesson.
  • Creating or improving developer docs, API guides, or tutorials.
  • Converting vague team notes into publishable how‑tos or postmortems.
  • Preparing leadership summaries focused on business impact.
  • Editing existing content to be more specific, scannable, and actionable.

Best practices

  • Lead every piece with the concrete value the reader will gain.
  • Prefer specific numbers, code snippets, and before/after examples.
  • Structure for scanning: clear headings, short paragraphs, and one idea per section.
  • Remove hedge words and corporate fluff; every sentence must earn its place.
  • Declare trade-offs and limits—honesty builds trust and usefulness.

Example use cases

  • Turn notes from a sprint retrospective into a 700-word blog post that highlights a measurable QE improvement.
  • Generate API documentation from TypeScript service code including tested code examples.
  • Edit an internal QA playbook to a concise, scannable checklist for onboarding new QE engineers.
  • Create a short leadership brief that links a testing change to metrics like bug rate and cycle time.

FAQ

How specific should examples be?

Include exact numbers, code snippets, or command outputs when available. If you only experimented, label it as such and describe the scope.

Can this skill generate full articles from scratch?

Yes. It works best when given a clear promise (title), target audience, and at least one concrete result or example to build from.