Skip to content This library is free, offered as dana. If it helps your work, donate here →
penguin tree ai
← back to libraryDonate here

This is one of 3,622 free prompts in the penguin tree ai library. Sign up once and the whole library opens, with new prompts by email.

open the library →

Plain language translator

Rewrites jargon-heavy technical content into clear, accessible language calibrated to a target reading level, preserving accuracy while removing jargon, passive constructions, nominalizations, and unnecessary…

download .md

Purpose

Convert jargon-heavy technical writing into clear, accessible language that a non-expert can understand on first read — without losing accuracy or stripping out necessary detail. Produces a clean rewrite plus a transparent change log so the author can trust that nothing important was lost.

When to Use

Invoke this skill when the user asks to:

  • Rewrite technical documentation or a help article for end users
  • Simplify jargon-heavy copy so a general audience can understand it
  • Lower the reading level or grade level of a piece of writing
  • Turn engineering, legal, medical, or policy text into plain language
  • Rewrite an error message, onboarding flow, or UI text for clarity
  • Make a spec, changelog, or release note readable for non-technical stakeholders

Inputs Required

Before starting, collect:

  • Source text: The technical content to rewrite (paste directly)
  • Target audience: Who will read this (e.g., new customers, patients, small-business owners, internal non-technical staff)
  • Target reading level: Grade 6–8 (general public), Grade 9–10 (informed adult), or "as simple as accurate allows"
  • Terms to preserve: Any technical terms that must stay (brand names, legally required language, unavoidable domain terms)
  • Format constraint: Where this will live (help center, in-app tooltip, email, PDF) and any length limit
  • Tone: Warm/friendly, neutral/professional, or reassuring (for stressful topics like errors, billing, health)

If reading level is unspecified, default to Grade 7 for consumer content and Grade 9 for professional/B2B content, and note the choice.

Instructions

Step 1: Diagnose the Source

Before rewriting, identify what's making the text hard. Scan for:

  • Undefined jargon: Domain terms a non-expert wouldn't know
  • Nominalizations: Verbs turned into nouns ("the implementation of" → "we built")
  • Passive voice: "The form must be submitted" → "Submit the form"
  • Long sentences: Anything over 25 words or with 3+ clauses
  • Nested conditionals: Stacked if/when/unless logic
  • Buried instructions: Actions hidden inside explanation
  • Abstraction stacking: Multiple abstract nouns in a row ("optimization of resource utilization efficiency")

Note the dominant problems — this drives the rewrite priorities.

Step 2: Apply Plain Language Rules

Rewrite using these rules in priority order:

  1. Lead with the action or the answer. Tell the reader what to do or what's true first, then explain.
  2. Cut jargon or define it inline. Replace each unpreserved term with a plain equivalent. If a preserved term must stay, add a short parenthetical definition the first time it appears.
  3. Convert passive to active. Name who does what.
  4. Split long sentences. Target 15–20 words average; hard cap 25. One idea per sentence.
  5. Un-nominalize. Turn noun-heavy phrases back into verbs.
  6. Use "you" and "we." Address the reader directly; name the product or company as "we."
  7. Simplify vocabulary. Prefer the shorter, more common word ("use" not "utilize," "help" not "facilitate," "start" not "initiate").
  8. Make lists out of steps and conditions. Sequential actions → numbered list. Multiple conditions → bullets.
  9. Keep it concrete. Replace abstractions with specific, visible things or actions.

Step 3: Preserve Accuracy

Guard against oversimplification:

  • Do not remove a caveat, exception, or safety condition — rephrase it plainly instead
  • Do not change the meaning of a required or legal statement — simplify the wording, not the intent
  • Flag any place where plain language and precision genuinely conflict, and choose accuracy while noting the tension

Step 4: Calibrate Reading Level

Match the target grade level:

  • Grade 6–8: Average sentence 12–15 words; almost no words over 3 syllables unless preserved; define every term
  • Grade 9–10: Average sentence 15–20 words; some domain vocabulary allowed with light definition
  • Read the rewrite aloud mentally — if a sentence needs a re-read to parse, split or simplify it.

Step 5: Build the Change Log

For every significant change, record: the original phrase → the rewrite → the reason (jargon removed, passive fixed, sentence split, term defined, etc.). This lets the author verify nothing was lost.

Output Format

  • Structure: Three sections — Plain-Language Version, Change Log (table), Reading-Level Summary
  • Length: Rewrite matches or is shorter than the source; change log covers every meaningful edit
  • Format: Rewrite as clean prose/lists ready to publish; change log as a 3-column table (Original / Rewrite / Reason)
  • Sections: 1. Plain-Language Version — the finished, publish-ready rewrite 2. Change Log — table of original phrase, rewrite, and reason 3. Reading-Level Summary — target level, estimated level achieved, average sentence length, and any accuracy tensions flagged
  • Tone: The rewrite matches the requested reader tone; the change log and summary are matter-of-fact and specific

Quality Checklist

Before delivering output, verify:

  • [ ] No unpreserved jargon remains, or every retained term is defined inline on first use
  • [ ] Average sentence length matches the target reading level; no sentence exceeds 25 words
  • [ ] Instructions appear as numbered steps and conditions appear as bullets where applicable
  • [ ] No caveat, exception, or required statement was dropped — accuracy is intact
  • [ ] The change log accounts for every meaningful edit with a stated reason
  • [ ] The rewrite is equal to or shorter than the source in word count

Notes

  • The most common failure in plain-language work is deleting nuance for the sake of simplicity — the change log exists to make every cut visible and reversible.
  • Error messages and stressful content (billing, health, account access) should get the reassuring tone: say what happened, what it means, and what to do next, in that order.
  • When a term genuinely can't be simplified without losing meaning, keep it and define it once — don't invent a vague substitute that misleads.
  • If the source contains multiple distinct pieces (a paragraph plus an error string plus a warning), rewrite each in its own labeled block rather than merging them.

How to use this skill

This file is a Claude Code skill in Anthropic's standard format — markdown with YAML frontmatter at the top.

Installing in Claude Code:

  • ~/.claude/skills/<folder-name>/SKILL.md — auto-loads in every session anywhere on your machine (recommended for skills you'll use across multiple projects)
  • <your-project>/.claude/skills/<folder-name>/SKILL.md — auto-loads only when working in that project (recommended for project-specific skills)

Restart Claude Code or open a new session to register.

Using in Claude.ai, ChatGPT, Gemini, or other AI tools:

  1. Drag this file into a new chat, or copy and paste its contents
  2. Send your task or request as your next message — the AI will apply the skill where it fits

For Claude Code skill details: https://docs.anthropic.com/en/docs/claude-code/skills