Write Well

Strip every sentence to its cleanest components

Claude Code Skill · Prose Editing · TDD-Tested

---

A Claude Code skill for writing prose that doesn't sound like AI wrote it. A tight reference an agent can actually apply: four cuts, a five-step edit pass, red flags, and a full 100-principle canon for when you need to go deep.

Features

• The Four Cuts — A repeatable edit pass: kill filler adverbs, break concept-noun stacks, delete throat-clearing, swap long words for short
• Edit-Pass Checklist — Five ordered checks (read aloud · hunt clutter · test the lead · test the close · voice check) you run after drafting
• Red Flags Library — Phrases and patterns that mean stop and rewrite — corporate openers, generic adjectives, em-dash chains, summary closers
• Rationalization Table — Closes the loopholes agents reach for under pressure ("it needs to sound professional," "I'll fix it later")
• Form-Specific Reference — All 100 principles organized by Principles, Methods, Forms (interview, memoir, science, business, sports, criticism, humor, travel), and Attitudes
• TDD-Tested — Built via the superpowers:writing-skills RED→GREEN→REFACTOR cycle: baseline scenarios run without the skill, failures catalogued, skill written against those failures, then re-tested

Installation

Via skills CLI (recommended)

bunx skills add 4thel00z/write-well
# or
npx skills add 4thel00z/write-well

Manual install (Claude Code)

Personal:

git clone https://github.com/4thel00z/write-well.git /tmp/write-well-src \
  && cp -r /tmp/write-well-src/skills/write-well ~/.claude/skills/ \
  && rm -rf /tmp/write-well-src

Project-local:

git clone https://github.com/4thel00z/write-well.git /tmp/write-well-src \
  && cp -r /tmp/write-well-src/skills/write-well .claude/skills/ \
  && rm -rf /tmp/write-well-src

The skill auto-loads on next session start.

Codex / other agents

Personal skills for Codex live in ~/.agents/skills/:

git clone https://github.com/4thel00z/write-well.git /tmp/write-well-src \
  && cp -r /tmp/write-well-src/skills/write-well ~/.agents/skills/ \
  && rm -rf /tmp/write-well-src

Quickstart

1. Trigger the skill

The skill activates automatically when you ask the agent to write or edit prose. You can also invoke it directly:

/write-well

Triggers include: blog posts, articles, essays, memos, announcements, release notes, post-mortems, narrative documentation — anything written for humans (not code, not API tables).

2. Apply The Four Cuts

When generating or editing prose, the agent runs four passes in order:

#	Cut	What it kills
1	Filler adverbs & qualifiers	very, basically, essentially, slightly, just, sort of, of course, surprisingly, carefully...
2	Concept-noun stacks	"the operational complexity of maintaining X" → "X was hard to maintain"
3	Throat-clearing	"What follows is an honest account of..." — just say the thing
4	Long words	utilize → use · implement → build · in order to → to

3. Run the Edit-Pass Checklist

After drafting:

1. Read aloud — stumbles mean rewrite
2. Hunt clutter — delete every word that, removed, doesn't change meaning
3. Test the lead — does sentence one make you read sentence two?
4. Test the close — stop at the nearest exit; don't summarize
5. Voice check — does it sound like you, or a press release?

4. Reach for the principles when stuck

cat ~/.claude/skills/write-well/references/principles.md

100 numbered principles, four parts (Principles, Methods, Forms, Attitudes). Use it when the SKILL.md quick reference doesn't cover your case — interviewing a source, writing a memoir scene, reviewing a film, opening a sports piece.

Before / After

Real baseline output from a Claude subagent (51 words, abstract):

The cognitive overhead of tracing a single request through six hops, the operational complexity of maintaining schema compatibility across teams, and the slow erosion of our ability to refactor across boundaries began to outweigh the autonomy we had gained.

Same agent, same prompt, with the skill loaded (30 words, concrete, rhythmic):

Tracing a request through six services took hours. Schemas drifted. Refactoring across team boundaries became impossible. The autonomy we'd won no longer paid for what it cost.

Verbs replace noun-stacks. One sentence becomes four.

Architecture

Layout follows the skills.sh convention — skills live under skills/<skill-name>/, with reference material in references/.

write-well/
├── README.md                              This file
├── logo.png                               Wordmark
├── package.json
└── skills/
    └── write-well/
        ├── SKILL.md                       Main reference — Four Cuts, checklist, red flags (644 words)
        └── references/
            └── principles.md              The full 100-principle canon (~1300 words)

SKILL.md frontmatter

---
name: write-well
description: Use when writing or editing prose for humans - blog posts,
  articles, essays, memos, announcements, release notes, post-mortems,
  narrative documentation. Use when output sounds like corporate-speak,
  contains hedging or filler adverbs, stacks abstract nouns, opens with
  throat-clearing, or feels generic and voiceless.
---

The description follows CSO guidance: triggering conditions only, no workflow summary. This prevents agents from "following the description" instead of reading the skill.

License

MIT