# understandable

Adopt this skill: https://proskills.md/skills/other/hsheimbuch-understandable

Page: https://proskills.md/skills/other/hsheimbuch-understandable
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: SKILL.md
size: 10227
sha: f2d0db7d4b97ef558fca93177af24494987245dd
upstream: https://github.com/hsheimbuch/understandable/blob/HEAD/SKILL.md

```text
---
name: understandable
description: Makes Claude's prose easy to read on the first pass, using findings from the 2026 study "Why is AI-generated language so hard to understand?" (Clark, Martin, and Mahowald). Use it when the user says a reply is dense, cryptic, jargon-heavy, hard to follow, or "Claudish", or asks for plainer or clearer wording. Also use it when writing or editing prose that people will read closely, such as explanations, end-of-task summaries, documentation, READMEs, and pull request descriptions. It can cover Claude's own replies for the rest of a session, or rewrite and check text and files that the user supplies.
license: MIT
allowed-tools: Read(/${CLAUDE_SKILL_DIR}/**)
metadata:
  version: "1.0.0"
  paper: "arXiv:2610.29162"
---

# Understandable

Recent models write sentences that are correct but slow to read. Clark, Martin, and Mahowald (2026) compared text from 14 models with human writing and with paraphrases of the same content. Frontier models overused six features that psycholinguistics links to reading difficulty, and the gap was largest in long chats and coding sessions. The authors trace the gap to post-training that rewards correct answers in few tokens. That compression saves tokens, but readers pay for it with working memory and re-reading.

This skill pushes the other way while you write. Spend a word wherever it saves the reader effort, and keep the content the same.

## What to do now

The user's arguments: $ARGUMENTS

- **No arguments**: for the rest of this session, apply the rules below to everything that you write for people, including replies, summaries, code comments, commit messages, and documents. If your previous reply in this conversation was dense and broke several of these rules, rewrite it now. Otherwise, confirm in one short sentence and carry on.
- **`off`**: stop applying the rules, and confirm in one short sentence.
- **`check` followed by a file or text**: review it without editing. For each hard spot, quote it, name the rule it breaks, and suggest a rewrite. End with the two or three patterns that occur most often.
- **A file path**: rewrite the prose in that file in place. Leave code, front matter, links, identifiers, quotations, and data tables as they are. In a code file, change only comments and docstrings. Then list the main changes in a few bullets.
- **Any other text**: rewrite it, and reply with the new version only.

If you loaded this skill yourself for a writing task, apply the rules to that task. Style rules from the user or the project come first.

## The rules

Each rule targets a construction that the study found overused. Apply them with judgment: people use both forms of most of these choices, and they pick one by context.

### 1. Keep each subject close to its verb

The reader holds the subject in memory until the verb arrives, and every word in between adds to that load. Keep the stretch before the verb short:

- Put a list after the verb, often after a colon, not in the subject.
- Put an aside in parentheses or dashes after the verb, or in its own sentence.
- Move a long modifier or relative clause out of the subject, or give it its own sentence.

- Hard: "The guitar sitting in the corner because you're still 'deciding' teaches you zero chords."
- Clear: "You won't learn any chords while the guitar sits in the corner and you keep 'deciding'."
- Hard: "All five expression shapes — attribute access, subscript, calls, nested calls, string literals — leave `current` on `NAME('b')`."
- Clear: "All five kinds of expression leave `current` on `NAME('b')`: attribute access, subscripts, calls, nested calls, and string literals."

### 2. Don't stack nouns

Three or more nouns in a row hide how the words relate ("Squad Helps Dog Bite Victim"), so the reader has to work out the grouping. Use at most two in a row, unless the phrase is an established term that the reader knows, such as "pull request" or "unit test". Unpack the rest with a verb or with "of", "for", or "that".

- Hard: "Fixed absolute dotfile backup path handling."
- Clear: "Fixed how backups handle absolute paths to dotfiles."

### 3. Mark relative clauses with "that", "which", or "who"

Object relatives are harder to read than subject relatives: compare "the bug that the test missed" with "the test that missed the bug". Dropping "that" also removes the signal that a clause has started. Keep the relative pronoun when the clause has a full noun as its subject or when the clause is long. Short clauses with a pronoun subject read fine: "the job you hate". If two noun phrases still crowd together, give the clause its own sentence.

- Hard: "The others check behaviour the old code never reached."
- Clear: "The other tests check behavior that the old code never reached."

### 4. Keep the small words that show structure

After verbs such as "know", "find", "show", "confirm", and "notice", write "that" before a clause that starts with a noun phrase. Without it, the reader first takes the noun as the verb's object, as in "I found the config file...". Keep articles, prepositions, and subjects in prose. People drop these optional words when the next words are easy to predict. Models trained under length pressure learned to drop them everywhere. In prose, use words for relations, not arrows, symbols, or emoji.

- Hard: "I found the config file was missing."
- Clear: "I found that the config file was missing."
- Hard: "New tests for paths with spaces, dry-run write prevention, and idempotent config reinstalls."
- Clear: "I added tests for three cases: paths with spaces, dry runs that must not write anything, and reinstalling the config twice."

### 5. Use ordinary verbs, not nouns turned into verbs

A noun used as a verb forces the reader to reanalyze the word in the middle of the sentence, as in "calendar it" or "footnote it". Established ones are fine, such as email, text, and google, or cache, stub, and commit for developers. Coined ones are not.

- Hard: "So yes, calendar it."
- Clear: "So yes, put it on your calendar."

### 6. Give human actions to people, not to things

Readers use animacy to work out who did what. When code, a file, or an idea "swallows", "promises", "forgets", "bites", or "hopes", the reader has to stop and decode a metaphor. All nine frontier models in the study did this more often than people do. Say literally what happens. Plain technical usage is fine: a function returns a value, a server accepts a connection, a test expects a result.

- Hard: "`is_file()` swallows that and returns False."
- Clear: "`is_file()` catches that error and returns False."
- Hard: "The docstring promises they're skipped."
- Clear: "The docstring says that they are skipped."

### 7. Use common words in their usual combinations

Readers process predictable words faster. Rare pairings and coinages make them stop, for example "reader-patience budget", "verified red", or "a gear trap". All nine frontier models in the study used more rare word pairs than people do. If a phrase would make a reader pause, say it the way most people would. In technical writing, prefer literal wording to metaphor, and define a term before you rely on it.

- Hard: "Every behavioral test was verified red against the original source."
- Clear: "I ran every behavior test against the original code and confirmed that each one failed there."

### 8. Give each sentence one main idea

People spread information evenly through a sentence, so that no part of it overloads the reader. Split a sentence that carries two main points or introduces several new terms at once. Keep most sentences under about 25 words, and put the main point first.

- Hard: "No new branch, no change in control flow, just closing the gap in an existing check that covered `str` but forgot its sibling scalar-like type `bytes`."
- Clear: "This change adds no new branch and does not change the control flow. It only fixes an existing check that handled `str` but not the similar type `bytes`."

## When to take extra care

The study found the strongest effects in long, multi-turn chats and in coding sessions, and the weakest in single essays. Be most careful:

- late in long sessions,
- in summaries at the end of a task, especially after many tool calls,
- when you explain code changes, bugs, or test results.

In those summaries, say what you changed, where, and why, in full sentences. Put file and function names in code formatting inside ordinary sentences.

## Don't overcorrect

- People use both the short and the long form of each choice above, depending on context. Don't swing to the other extreme, such as adding "that" to every clause or never letting two nouns touch.
- Don't pad. Add the words that show structure, not filler, hedges, or repetition. A rewrite may come out slightly longer, but it should not say more.
- Don't simplify the ideas. Hard ideas don't need hard sentences: a study of legal writing found that its difficulty came from the writing, not from the concepts.
- Keep names, numbers, code, quotations, and the user's own terms exactly as they are.
- Keep the register. A casual chat stays casual, and a formal document stays formal.

## Reviewing text

For replies, keep the rules in mind as you write, and check a long reply against the questions below before you send it. For a `check`, a file rewrite, or a long document such as a README:

1. Read [references/constructions.md](references/constructions.md) first. It has more examples from the study and the cases to leave alone.
2. Go through the text sentence by sentence with the questions below, and fix what you find.
3. Reread the result once as a newcomer would, and confirm that the meaning has not changed.

The questions, one per rule:

1. Is a subject far from its verb, because of a list, an aside, or a long modifier?
2. Are three or more nouns stacked?
3. Does a relative clause lack "that" or "which" where it would help?
4. Is a small structural word missing, or does a symbol stand in for words?
5. Is a noun used as a verb in a way that people rarely say?
6. Is a thing doing something that only a person does?
7. Would a phrase make a reader stop to decode it?
8. Does a sentence carry more than one main idea?
```

## File: README.md
size: 7062
sha: 91f48731405c6ebbe66b1d37cd88164651191938
upstream: https://github.com/hsheimbuch/understandable/blob/HEAD/README.md

````text
# understandable

A Claude Code skill that makes Claude's writing easier to read. It applies the findings of *Why is AI-generated language so hard to understand?* (Clark, Martin, and Mahowald, 2026) while Claude writes. Nothing is retrained.

**Before:**

> Swept the repo and fixed the three bugs I could verify. The `parse_args()` fallback was silently swallowing malformed flags; it now surfaces a proper error. Config reload path handling regressions are fixed too, and every behavioral test was verified red against the original source.

**After:**

> I went through the repository and fixed the three bugs that I could confirm. `parse_args()` used to accept malformed flags without an error, and it now reports one. Reloading the config no longer breaks how file paths are handled. I ran each new test against the original code and confirmed that it failed there.

## Why this exists

The study compared text from 14 language models with human writing, and with paraphrases of the same content. Frontier models overused six features that psycholinguistics links to slower reading:

| Feature | Example from the study | Plainer version |
| --- | --- | --- |
| Subject far from its verb | "The guitar sitting in the corner because you're still 'deciding' teaches you zero chords." | "You won't learn any chords while the guitar sits in the corner and you keep 'deciding'." |
| Stacked nouns | "Policy 1's class-time shutdown requirement" | "Policy 1's rule that phones stay off during class" |
| Object relatives without "that" | "the others check behaviour the old code never reached" | "the other tests check behavior that the old code never reached" |
| Nouns used as verbs | "So yes, calendar it." | "So yes, put it on your calendar." |
| Things that act like people | "The docstring promises they're skipped." | "The docstring says that they are skipped." |
| Rare word pairs | "Every behavioral test was verified red against the original source." | "I ran every behavior test against the original code and confirmed that each one failed there." |

The authors' explanation is post-training that rewards correct answers in few tokens, with no check that a person can follow the text. They support it with an experiment. In that experiment, a small model trained with a length penalty learned to choose the shorter of two equal phrasings almost every time. For example, it dropped the optional "that", even in constructions that it was never trained on. People choose between such forms by context. The effects were strongest in long chats and coding sessions.

These habits are not fixed. Claude Opus 5.5 scored lower than Claude Opus 5 on 19 of 21 comparisons. Because each feature is specific and has a name, a model can be told to avoid it. That is what this skill does.

For a fuller summary of the study, see [docs/paper-notes.md](docs/paper-notes.md).

## What the skill does

When you run `/understandable`, Claude follows eight rules for the rest of the session:

1. Keep each subject close to its verb.
2. Don't stack nouns.
3. Mark relative clauses with "that", "which", or "who".
4. Keep the small words that show structure.
5. Use ordinary verbs, not nouns turned into verbs.
6. Give human actions to people, not to things.
7. Use common words in their usual combinations.
8. Give each sentence one main idea.

Rules 1 to 3 and 5 to 7 match the six features that the study measured. Rule 4 comes from the study's experiment with a length penalty, and rule 8 comes from the research on information density that the study builds on.

The skill also tells Claude not to overcorrect. People use both forms of each choice, so Claude should not add "that" everywhere, pad its replies, or simplify the ideas. Replies may come out slightly longer, but they should not say more.

## Install

**For all your projects** (recommended):

```bash
git clone https://github.com/hsheimbuch/understandable ~/.claude/skills/understandable
```

To update it later, run `git -C ~/.claude/skills/understandable pull`.

**For one project**, so that everyone on the project gets it:

```bash
git submodule add https://github.com/hsheimbuch/understandable .claude/skills/understandable
```

**As a plugin**:

```bash
claude plugin marketplace add hsheimbuch/understandable
claude plugin install understandable@understandable
```

Plugin skills carry the plugin's name as a prefix, so with this method the command is `/understandable:understandable`.

## Use

| Command | What happens |
| --- | --- |
| `/understandable` | Claude follows the rules for the rest of the session. If its last reply was dense, it rewrites that reply first. |
| `/understandable off` | Claude stops following the rules. |
| `/understandable check docs/guide.md` | Claude lists the hard-to-read spots in the file, with a rewrite for each, and changes nothing. |
| `/understandable docs/guide.md` | Claude rewrites the prose in the file. Code, links, and identifiers stay as they are. |
| `/understandable <text>` | Claude rewrites the text and returns the new version. |

Claude can also load the skill on its own when you ask for plainer wording, or when it writes documentation, READMEs, or pull request descriptions.

## How it works

- The skill is plain instructions. Claude Code loads `SKILL.md` into the conversation when you invoke it.
- `SKILL.md` is short, because its text stays in context for the whole session. The longer catalog in `references/constructions.md` loads only for `check` and for file rewrites.
- After `/compact`, Claude Code re-attaches the start of each skill that you invoked, and the rules sit at the start. In a very long session, run `/understandable` again if the old habits return.

## Limitations

- It covers English only.
- The study measured features that earlier research links to reading difficulty. It did not test how well people understood the AI text itself.
- The skill changes how Claude writes. It does not change what Claude knows, or the code that Claude writes.

## Repository layout

- `SKILL.md`: the skill, with its modes and the eight rules
- `references/constructions.md`: the full catalog, with examples from the study
- `docs/paper-notes.md`: a summary of the study, and how each rule follows from it
- `.claude-plugin/`: the plugin and marketplace manifests

## Author

Heinrich Heimbuch, [github.com/hsheimbuch](https://github.com/hsheimbuch)

## Credits

The rules and the examples come from this study. This project is not affiliated with its authors.

```bibtex
@misc{clark2026understand,
  title         = {Why is {AI}-generated language so hard to understand?},
  author        = {Clark, Thomas Hikaru and Martin, Matias B. and Mahowald, Kyle},
  year          = {2026},
  eprint        = {2610.29162},
  archivePrefix = {arXiv},
  primaryClass  = {cs.CL},
  url           = {https://arxiv.org/abs/2610.29162}
}
```

## License

The skill and the documentation are under the [MIT License](LICENSE). The examples quoted from the study are under the paper's license, [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/).
````

## File: references/constructions.md
size: 28646
sha: 583f45b83bbd3da0b35956fcc5c76fdc3ef4d7d0
upstream: https://github.com/hsheimbuch/understandable/blob/HEAD/references/constructions.md

```text
# Constructions that slow readers down

This file expands the eight rules in SKILL.md. Read it before a `check` or a file rewrite.

Each section says what to look for, why it slows readers down, what the study found, how to fix it, and when to leave it alone. Examples marked "study" are quoted from Clark, Martin, and Mahowald (2026), mostly from Table 2 and Figure 1, with the model and setting in brackets. The paper is licensed CC BY 4.0. The rewrites are ours, and they keep to what each sentence says, because the surrounding conversation is not in the paper.

## Contents

1. [Subject far from its verb](#1-subject-far-from-its-verb)
2. [Stacked nouns](#2-stacked-nouns)
3. [Object relatives without "that"](#3-object-relatives-without-that)
4. [Dropped structure words](#4-dropped-structure-words)
5. [Nouns used as verbs](#5-nouns-used-as-verbs)
6. [Things that act like people](#6-things-that-act-like-people)
7. [Rare word pairs and coinages](#7-rare-word-pairs-and-coinages)
8. [Too much in one sentence](#8-too-much-in-one-sentence)
9. [Short and long forms: how people choose](#short-and-long-forms-how-people-choose)
10. [Where the problem is worst](#where-the-problem-is-worst)
11. [A worked example](#a-worked-example)
12. [Sources](#sources)

## 1. Subject far from its verb

**What to look for.** Many words between a subject and its verb, or between a verb and its object. Common causes:

- a long modifier after the subject,
- a list or a dash-enclosed aside after the subject,
- a relative clause inside the subject,
- a long run of modifiers before a noun.

**Why it slows readers down.** Readers keep the subject in working memory until its verb arrives, and that memory fades with distance (Gibson 1998, 2000). Across 37 languages, people order words so that related words sit close together (Futrell, Mahowald, and Gibson 2015).

**What the study found.** In conversation, most frontier models produced longer dependencies than human writing. In chat and coding, they also produced longer ones than paraphrases of their own text. The essays did not show this effect.

**How to fix it.**

- Move a long modifier after the verb, or give it its own sentence.
- Put a list at the end of the sentence, after a colon.
- Start with a short subject. If the condition is long, make it an opening clause: "When X happens, Y..."
- Put the heaviest phrase last.

**Examples.**

- Hard: "The guitar sitting in the corner because you're still 'deciding' teaches you zero chords." (study: Claude Sonnet 5, chat)
- Clear: "You won't learn any chords while the guitar sits in the corner and you keep 'deciding'."

- Hard: "All five expression shapes — attribute access, subscript, calls, nested calls, string literals — leave `current` on `NAME('b')`, and the full template renders correctly." (study: Claude Fable 5, coding)
- Clear: "All five kinds of expression leave `current` on `NAME('b')`: attribute access, subscripts, calls, nested calls, and string literals. The full template renders correctly."

- Hard: "A lattice constructed with duplicate points, or a `SymbolSet` with colliding labels/names, can overwrite internal dictionary or attribute mappings." (study: GPT-5.6 Terra, coding)
- Clear: "Two kinds of input can overwrite internal mappings in dictionaries or attributes: a lattice that was built with duplicate points, and a `SymbolSet` whose labels or names collide."

- Hard: "Projects completed on weekends, during school events, or over the summer could all count." (study: GPT-5.6 Sol, essay)
- Clear: "Projects could all count, even if students completed them on weekends, during school events, or over the summer."

- Hard: "Class time, where a total blackout policy would apply under Policy 1, remains protected and focused." (study: Claude Sonnet 5, essay)
- Clear: "Under Policy 1, phones would be banned completely during class, so class time stays protected and focused."

- Hard: "Has the building had water, mold, structural, or insurance claims?" (study: GPT-5.6 Luna, chat)
- Clear: "Has the building had any claims for water, mold, or structural damage, or any other insurance claims?"

- Hard: "A cat who can always get up and away is a much calmer cat." (study: Claude Opus 5, chat)
- Clear: "A cat is much calmer when it can always climb up and get away."

**Leave it alone when** the words in between are few and short, as in "The tests in this folder pass". An opening clause that sets the scene is also fine: "When the cache is empty, the loader reads from disk."

## 2. Stacked nouns

**What to look for.** Three or more nouns in a row, each one modifying the next: "class-time shutdown requirement", "absolute dotfile backup path handling". Hyphens do not help: "reader-patience budget" is still three nouns.

**Why it slows readers down.** A stack does not say how its parts relate, so the reader has to infer the grouping. Some stacks are ambiguous, like the headline "Squad Helps Dog Bite Victim" (Cooper 1980). Eye-tracking studies show that new compounds slow reading (Staub et al. 2007; Cohen and Staub 2014).

**What the study found.** In conversation, most frontier models stacked more nouns than human writers did. In chat and coding, they also stacked more than paraphrases of their own text.

**How to fix it.**

- Name the relation with a preposition: "money market funds at a brokerage".
- Turn one noun into a clause: "the rule that phones stay off during class".
- Keep established two-word terms together and unpack the rest. "The pull request description" is fine. "The pull request description template update" is not.

**Examples.**

- Hard: "I acknowledge concerns about distraction, but Policy 1's class-time shutdown requirement directly addresses this." (study: Kimi K2.5, essay)
- Clear: "I acknowledge the concerns about distraction, but Policy 1 addresses them directly: it requires phones to be off during class."

- Hard: "Fixed absolute dotfile backup path handling while preserving the `:` marker used during reinstall." (study: GPT-5.6 Luna, coding)
- Clear: "Backups now handle absolute paths to dotfiles correctly. The `:` marker that reinstall uses still works."

- Hard: "Online banks (Ally, Marcus, Capital One 360, Discover, SoFi) or brokerage money market funds (Fidelity's SPAXX, Vanguard's VMFXX) are the standard options." (study: Claude Opus 5, chat)
- Clear: "There are two standard options. One is an online bank, such as Ally, Marcus, Capital One 360, Discover, or SoFi. The other is a money market fund at a brokerage, such as Fidelity's SPAXX or Vanguard's VMFXX."

- Hard: "Summer park district classes are a whole thing in Chicago and people actually do them." (study: GLM-5, chat)
- Clear: "In Chicago, the park district runs summer classes, and lots of people take them."

- Hard: "Every long line in that list is pre-existing (long error-message string literals, which black leaves alone since it doesn't split strings without `--preview`)." (study: Claude Opus 5, coding)
- Clear: "Every long line in that list was already there. They are long string literals that hold error messages, and black leaves them alone because it splits strings only with `--preview`."

- Hard: "You've basically installed a horror movie soundtrack generator in your skull." (study: Claude Sonnet 5, chat)
- Clear: "Basically, your brain now plays scary music, like in a horror movie."

**Leave it alone when** the stack is a fixed term in the reader's field, such as "pull request", "unit test", "cell phone policy", or "error message". Two nouns in a row are usually fine.

## 3. Object relatives without "that"

**What to look for.** A noun followed directly by a clause that has its own subject, with no "that", "which", or "who" between them: "the behaviour the old code never reached". Look hardest when the clause has a full noun phrase as its subject, such as "the old code", rather than a pronoun such as "I" or "you". Long clauses and clauses inside other clauses need the same care.

**Why it slows readers down.** In an object relative, the described noun is the object of the verb inside the clause. These clauses are harder to process than subject relatives, partly because of their unusual word order and their longer dependencies (Staub 2010). The difference shrinks when the two nouns differ in animacy and when the pattern is frequent (Mak et al. 2006; Reali and Christiansen 2007). Without "that", two noun phrases meet with nothing to mark the boundary between them.

**What the study found.** Models used object relatives without "that" more often than paraphrases of the same content did, and used them with "that" less often. The authors read this as a preference for skipping optional words. In conversation, most frontier models also used more of the reduced form than human writers did.

**How to fix it.**

- Add "that" or "which".
- If two noun phrases still crowd together, give the clause its own sentence.
- Or recast the clause so that the described noun is its subject.

**Examples.**

- Hard: "Three fail on the old code; the others check behaviour the old code never reached." (study: Claude Opus 5.5, coding)
- Clear: "Three of the tests fail on the old code. The other tests check behavior that the old code never reached."

- Hard: "These are the exact skills the worksheet hoped to teach, but she has learned them because she wanted an answer." (study: Claude Opus 5.5, essay)
- Clear: "These are exactly the skills that the worksheet was meant to teach, but she has learned them because she wanted an answer."

- Hard: "The case/when fix is technically more impressive, but the unclosed-tag errors are the papercut people feel day-to-day." (study: GLM-5, coding)
- Clear: "The case/when fix is more impressive technically. But the errors from unclosed tags are the small annoyance that people run into every day."

**Leave it alone when** the clause is short and its subject is a pronoun. These read easily, and the study's own examples include many of them:

- "That's 'leave the job you hate' money." (study: Kimi K2.5, chat)
- "That's great for a beginner, honestly one of the best genres you could pick." (study: Claude Opus 5.5, chat)
- "I am writing to share my thoughts on the cell phone policy you are considering." (study: Claude Opus 5, essay)

## 4. Dropped structure words

**What to look for.**

- A clause after "know", "find", "show", "confirm", "notice", "see", "report", or "check" that starts with a noun phrase and has no "that": "I found the config file was missing".
- An optional word dropped from any of the short-or-long choices in the [table below](#short-and-long-forms-how-people-choose).
- Prose without subjects, verbs, or articles: "New tests for X, Y, and Z." or "Swept the codebase."
- Arrows, symbols, or emoji in place of words, as in "parse -> validate".

**Why it slows readers down.** Words such as "that" carry little meaning of their own, but they tell the reader how the sentence is built. People include an optional "that" more often when the clause after it is harder to predict. This spreads information evenly through the sentence (Levy and Jaeger 2007; Jaeger 2010). Without "that", a reader may first take the noun as the verb's object and then have to go back, as in a garden-path sentence (Christianson et al. 2001).

**What the study found.** The authors fine-tuned a small model with a penalty on the length of its output. With that penalty, it learned to choose the shorter form of each trained choice almost every time, while people choose by context. Without a constraint that kept it close to the original model, it left out the optional "that" more than 98 percent of the time in the two trained "that" constructions. The habit spread to two "that" constructions that it was never trained on, "sure (that)" and "so (that)".

**How to fix it.**

- Put "that" back after the verbs above when a full noun phrase follows.
- Write complete sentences in prose. A list of changes can use short items, but keep the articles and prepositions in them.
- Write "leads to", "becomes", or "then" instead of an arrow.

**Examples.**

- Hard: "I found the config file was missing."
- Clear: "I found that the config file was missing."

- Hard: "New tests for paths with spaces, dry-run write prevention, and idempotent config reinstalls." (study: GPT-5.6 Terra, coding)
- Clear: "I added tests for three cases: paths with spaces, dry runs that must not write anything, and reinstalling the config twice."

- Hard: "Swept the codebase and fixed the bugs I could verify." (study, Figure 1, coding)
- Clear: "I went through the codebase and fixed the bugs that I could confirm."

**Leave it alone when** the clause is short and easy to predict. "I think it works" and "She said she'd come" need no "that".

## 5. Nouns used as verbs

**What to look for.** A word that is normally a noun, used as a verb in a way that readers rarely see: "calendar it", "footnote it", "bucket these", "timebox it", "caveat that".

**Why it slows readers down.** Readers can work out new verbs like these (Clark and Clark 1979), but the change of word class makes them reanalyze the sentence (Thierry et al. 2008). People also process a word that can be either a noun or a verb differently from a word that can be only one of them (Frazier and Rayner 1987; Federmeier et al. 2000).

**What the study found.** Almost all frontier models used more nouns as verbs than paraphrases of the same content did.

**How to fix it.** Use the ordinary verb phrase, even when it is a word or two longer: "put it on your calendar", "put it in a footnote", "sort these into groups".

**Examples.**

- Hard: "So yes — calendar it." (study: Claude Fable 5, chat)
- Clear: "So yes, put it on your calendar."

- Hard: "And Austin has unusually high inventory, which cushions price spikes better than supply-constrained markets." (study: Claude Opus 5, chat)
- Clear: "Austin also has an unusually large supply of homes for sale, so prices there jump less than in markets where supply is tight."

- Hard: "In each case, the logic is the same: pooling independent judgments filters out individual errors." (study: Claude Fable 5, essay)
- Clear: "In each case, the logic is the same: when you combine independent judgments, individual errors cancel out."

**Leave it alone when** the verb is established for the reader, such as "email", "text", and "google", or "cache", "stub", "commit", "stage", and "merge" for developers. In a summary of Git work, "staging changes" is the normal term.

## 6. Things that act like people

**What to look for.** A thing, an idea, or a piece of code as the subject of a verb that normally needs a person. Typical verbs are swallows, eats, bites, promises, hopes, forgets, wants, asks, misunderstands, complains, chokes, and knows.

**Why it slows readers down.** Readers use animacy as a cue while they parse a sentence (Trueswell et al. 1994). When an inanimate subject meets one of these verbs, brain responses show signs of reanalysis (Kim and Osterhout 2005; Kuperberg 2007). Readers can decode the metaphor, but it costs them time.

**What the study found.** All nine frontier models used inanimate subjects with these verbs more often than human writing did. Most also used them more often than paraphrases of the same content did.

**How to fix it.** Say what literally happens, or make a person the subject.

**Examples.**

- Hard: "`is_file()` swallows that and returns False." (study, Section 3.1)
- Clear: "`is_file()` catches that error and returns False."

- Hard: "Puzzle patterns where this asymmetry bites" (study, Section 3.1)
- Clear: "Puzzle patterns where this asymmetry causes problems"

- Hard: "The docstring promises they're skipped when they 'appear anywhere in the `source_dir` path'; e.g. backing up a dotfolder like `~/.cache/foo` was not skipped." (study: Claude Fable 5, coding)
- Clear: "The docstring says that such files are skipped when they 'appear anywhere in the `source_dir` path'. But a hidden folder such as `~/.cache/foo` was still included in the backup."

- Hard: "No new branch, no change in control flow — just closing the gap in an existing check that covered `str` but forgot its sibling scalar-like type `bytes`." (study: Claude Sonnet 5, coding)
- Clear: "This change adds no new branch and does not change the control flow. It only fixes an existing check that handled `str` but not the similar type `bytes`."

- Hard: "Second, the time objection misunderstands how service actually functions." (study: Kimi K2.5, essay)
- Clear: "Second, people who object that service takes too much time misunderstand how it works."

- Hard: "The whole conversation is eating its own tail." (study: Claude Opus 5, chat)
- Clear: "The conversation keeps going in circles."

- Hard: "Sometimes chaos has a 1099; sometimes chaos expects you to remember it independently." (study: GPT-5.6 Sol, chat)
- Clear: "Sometimes the income comes with a 1099 form. Sometimes you have to remember to report it yourself."

**Leave it alone when** the usage is standard in the field. A function returns a value or takes arguments, a server accepts or refuses a connection, a test expects a value, the documentation says something, and a study shows a result.

## 7. Rare word pairs and coinages

**What to look for.** Words that people rarely put together, invented compounds, and private metaphors: "reader-patience budget", "verified red", "a gear trap", "later enrichments". Watch for one coinage repeated across a conversation.

**Why it slows readers down.** How fast people read a word depends on how predictable it is (Hale 2001; Levy 2008; Smith and Levy 2013). A surprising pair makes the reader stop and work out what is meant.

**What the study found.** In all three settings, almost all frontier models used more word pairs that never occur in human reference text than paraphrases of their own text did. Their text was also harder to predict for a simple model trained on human text. Compared with human writing, all nine frontier models used more rare word sequences. In the Olmo family, the effect grew from the base model to the instruction-tuned model to the reasoning model. One coinage, "verified red", appeared four times in a single coding conversation.

**How to fix it.**

- Say it the way most people would, even if that takes a few more words.
- In technical writing, prefer literal words to metaphor.
- Introduce a term once, define it, and then use it consistently.
- Avoid jargon that the reader does not share.

**Examples.**

- Hard: "Every behavioral test was verified red against the original source." (study: Claude Opus 5, coding)
- Clear: "I ran every behavior test against the original code and confirmed that each one failed there."

- Hard: "That's a really legitimate concern, and honestly it's the part most internet advice glosses over." (study: Claude Fable 5, chat)
- Clear: "That's a really legitimate concern, and honestly, it's the part that most online advice leaves out."

- Hard: "`as_documents: true` previously mutated the tag instance permanently, causing later enrichments to return `DocumentsList` unexpectedly." (study: GPT-5.6 Luna, coding)
- Clear: "Before this fix, `as_documents: true` changed the tag instance permanently. As a result, later enrichment steps returned a `DocumentsList` when they should not have."

- Hard: "It's not necessary, but it's surprisingly useful—and not really a gear trap." (study: GPT-5.6 Sol, chat)
- Clear: "You don't need it, but it's surprisingly useful, and it won't lead you into buying more and more gear."

- Hard: "Your instinct is right; the convoluted sentence you are currently reading is quietly eating its own reader-patience budget — footnote it." (the study's opening sentence, written to show several features at once)
- Clear: "You're right. This sentence is hard to read, and it wastes the reader's patience. Put it in a footnote."

**Leave it alone when** the phrase is a standard term or idiom for the reader, such as "race condition" or "happy path" for developers. Such terms are fine even when they look odd out of context.

## 8. Too much in one sentence

**What to look for.** A sentence with two or more main points, several new terms, a chain of semicolons or dashes, or more than about 25 words.

**Why it slows readers down.** People tend to spread information evenly across what they say, so that no stretch of it overloads the listener (Levy and Jaeger 2007; Meister et al. 2021). Dense stretches strain the same limited working memory that long dependencies do.

**What the study found.** The study did not measure sentence length as a feature. It adjusted dependency length for sentence length, and it left sentences over 30 words out of that measure. This rule follows from the research on information density that the study builds on, and from its finding that a length penalty pushes a model to compress.

**How to fix it.**

- Give each sentence one main idea. Split at "and", "but", semicolons, and dashes.
- Put the main point first and the details after it.
- Introduce one new term at a time.

**Example.**

- Hard: "The most substantive unfixed item is the existing xfailed lazy-intermediate Lookup behavior; the others are primarily compatibility, validation, or API-policy decisions." (study: GPT-5.6 Terra, coding)
- Clear: "The most important problem that is still unfixed is a known bug in `Lookup` with lazy intermediate values, which is already marked as an expected failure. The other open items are mostly decisions about compatibility, validation, or API policy."

## Short and long forms: how people choose

English often offers a short and a long way to say the same thing. The study's experiment with a length penalty used the pairs below. People use both forms and choose by context. A model trained under a length penalty came to pick the short form almost every time. When in doubt, and especially in a long or complex sentence, choose the form that makes the structure clearer.

| Choice | Short form | Long form | Prefer the long form when |
| --- | --- | --- | --- |
| Object relative | the book the professor wrote | the book that the professor wrote | the clause has a full noun as its subject, or is long |
| Complement clause | knew the answer was wrong | knew that the answer was wrong | the noun after the verb could be read as its object |
| Adjective and clause | was sure the door was locked | was sure that the door was locked | the clause is long |
| Purpose with "so" | spoke slowly so we could follow along | spoke slowly so that we could follow along | the clause is long |
| Purpose with "to" | left early to catch the train | left early in order to catch the train | the purpose comes far from its verb |
| Dative | gave his wife a gift | gave a gift to his wife | the recipient is long or new to the reader |
| Genitive | noticed the old house's roof | noticed the roof of the old house | the owner is long, or is a thing rather than a person |
| Quantifier | ate all the cookies | ate all of the cookies | either form is fine |
| Passive | a falling branch hit it | it was hit by a falling branch | the thing affected is the topic of the passage |

## Where the problem is worst

- Long, multi-turn chats and coding sessions showed larger effects than single essays. The authors suggest that long exchanges may push models toward compression.
- In coding sessions, the study analyzed the last message of each turn, which is usually a summary of the work. All of its coding examples come from these messages.
- In the Olmo family, the effects grew from the base model to the instruction-tuned model to the reasoning model.
- Newer models are not always worse. Claude Opus 5.5 scored lower than Claude Opus 5 in 19 of 21 comparisons of the difficulty measures.

## A worked example

Here is an end-of-task summary in the compressed style. It was written for this file and is not quoted from the study:

> Swept the repo and fixed the three bugs I could verify. The `parse_args()` fallback was silently swallowing malformed flags; it now surfaces a proper error. Config reload path handling regressions are fixed too, and every behavioral test was verified red against the original source. One thing worth calendaring: the lazy-intermediate `Lookup` xfail still bites on Python 3.13.

What goes wrong:

- "Swept the repo" has no subject.
- "Swallowing" and "bites" give human actions to code.
- "Config reload path handling regressions" stacks five nouns.
- "Verified red" and "lazy-intermediate `Lookup` xfail" are private coinages.
- "Calendaring" turns a noun into a verb.

The same content, rewritten:

> I went through the repository and fixed the three bugs that I could confirm.
>
> - `parse_args()` used to accept malformed flags without an error. It now reports one.
> - Reloading the config no longer breaks how file paths are handled.
> - I ran each new test against the original code and confirmed that it failed there.
>
> One problem is still open. A test for `Lookup` with lazy intermediate values is marked as an expected failure, and it still fails on Python 3.13. It is worth scheduling a fix.

The rewrite is about 25 words longer. Most of the added words make the structure visible: subjects, "that", and verbs that name what happened.

## Sources

The study:

- Clark, T. H., Martin, M. B., and Mahowald, K. (2026). Why is AI-generated language so hard to understand? arXiv:2610.29162. https://arxiv.org/abs/2610.29162

Work that the study cites and that this file refers to:

- Christianson, K., Hollingworth, A., Halliwell, J. F., and Ferreira, F. (2001). Thematic roles assigned along the garden path linger. Cognitive Psychology, 42(4).
- Clark, E. V., and Clark, H. H. (1979). When nouns surface as verbs. Language, 55(4).
- Cohen, A. L., and Staub, A. (2014). Online processing of novel noun-noun compounds. Quarterly Journal of Experimental Psychology, 67(1).
- Cooper, G., editor (1980). Squad Helps Dog Bite Victim, and Other Flubs from the Nation's Press.
- Federmeier, K. D., Segal, J. B., Lombrozo, T., and Kutas, M. (2000). Brain responses to nouns, verbs and class-ambiguous words in context. Brain, 123(12).
- Frazier, L., and Rayner, K. (1987). Resolution of syntactic category ambiguities. Journal of Memory and Language, 26(5).
- Futrell, R., Mahowald, K., and Gibson, E. (2015). Large-scale evidence of dependency length minimization in 37 languages. PNAS, 112(33).
- Gibson, E. (1998). Linguistic complexity: Locality of syntactic dependencies. Cognition, 68(1).
- Gibson, E. (2000). The dependency locality theory. In Image, Language, Brain. MIT Press.
- Hale, J. (2001). A probabilistic Earley parser as a psycholinguistic model. NAACL.
- Jaeger, T. F. (2010). Redundancy and reduction: Speakers manage syntactic information density. Cognitive Psychology, 61(1).
- Kim, A., and Osterhout, L. (2005). The independence of combinatory semantic processing. Journal of Memory and Language, 52(2).
- Kuperberg, G. R. (2007). Neural mechanisms of language comprehension: Challenges to syntax. Brain Research, 1146.
- Levy, R. (2008). Expectation-based syntactic comprehension. Cognition, 106(3).
- Levy, R., and Jaeger, T. F. (2007). Speakers optimize information density through syntactic reduction. NeurIPS 19.
- Mak, W. M., Vonk, W., and Schriefers, H. (2006). Animacy in processing relative clauses. Journal of Memory and Language, 54(4).
- Martínez, E., Mollica, F., and Gibson, E. (2022). Poor writing, not specialized concepts, drives processing difficulty in legal language. Cognition, 224.
- Meister, C., Pimentel, T., Haller, P., Jäger, L., Cotterell, R., and Levy, R. (2021). Revisiting the uniform information density hypothesis. EMNLP.
- Reali, F., and Christiansen, M. H. (2007). Processing of relative clauses is made easier by frequency of occurrence. Journal of Memory and Language, 57(1).
- Smith, N. J., and Levy, R. (2013). The effect of word predictability on reading time is logarithmic. Cognition, 128(3).
- Staub, A. (2010). Eye movements and processing difficulty in object relative clauses. Cognition, 116(1).
- Staub, A., Rayner, K., Pollatsek, A., Hyönä, J., and Majewski, H. (2007). The time course of plausibility effects on eye movements in reading. Journal of Experimental Psychology: Learning, Memory, and Cognition, 33(6).
- Thierry, G., et al. (2008). Event-related potential characterisation of the Shakespearean functional shift in narrative sentence structure. NeuroImage, 40(2).
- Trueswell, J. C., Tanenhaus, M. K., and Garnsey, S. M. (1994). Semantic influences on parsing. Journal of Memory and Language, 33(3).
```

## File: .claude-plugin/marketplace.json
size: 574
sha: 3d28f6b24442e912e7d22e61d18b923fb21597df
upstream: https://github.com/hsheimbuch/understandable/blob/HEAD/.claude-plugin/marketplace.json

```text
{
  "name": "understandable",
  "description": "The understandable skill for Claude Code: clearer prose, based on research into why AI-generated text is hard to read.",
  "owner": {
    "name": "Heinrich Heimbuch",
    "url": "https://github.com/hsheimbuch"
  },
  "plugins": [
    {
      "name": "understandable",
      "source": "./",
      "description": "Makes Claude's writing easier to read, using findings from the 2026 study \"Why is AI-generated language so hard to understand?\"",
      "category": "writing",
      "tags": ["writing", "readability"]
    }
  ]
}
```

## File: .claude-plugin/plugin.json
size: 569
sha: 5ef4c3cd560a8c485514bf27d5c2c02658daf658
upstream: https://github.com/hsheimbuch/understandable/blob/HEAD/.claude-plugin/plugin.json

```text
{
  "name": "understandable",
  "displayName": "Understandable",
  "version": "1.0.0",
  "description": "Makes Claude's writing easier to read, using findings from the 2026 study \"Why is AI-generated language so hard to understand?\"",
  "author": {
    "name": "Heinrich Heimbuch",
    "url": "https://github.com/hsheimbuch"
  },
  "homepage": "https://github.com/hsheimbuch/understandable",
  "repository": "https://github.com/hsheimbuch/understandable",
  "license": "MIT",
  "keywords": ["writing", "readability", "plain-language", "psycholinguistics", "skill"]
}
```

## File: .gitignore
size: 142
sha: d7000824ad4b2b82d078a176e63c350b6b4c7934
upstream: https://github.com/hsheimbuch/understandable/blob/HEAD/.gitignore

```text
# Local Claude Code settings
.claude/settings.local.json

# PDFs, such as a local copy of the paper. The README links to arXiv instead.
*.pdf
```

## File: docs/paper-notes.md
size: 8894
sha: c4cdedefee04da1f54521ca5f42995bca134e849
upstream: https://github.com/hsheimbuch/understandable/blob/HEAD/docs/paper-notes.md

```text
# Notes on the study

These notes summarize the paper behind this skill, and show how each rule in [SKILL.md](../SKILL.md) follows from it.

> Thomas Hikaru Clark (New York University), Matias B. Martin, and Kyle Mahowald (The University of Texas at Austin). 2026. *Why is AI-generated language so hard to understand?* arXiv:2610.29162 [cs.CL], version 1, 21 October 2026. Licensed CC BY 4.0. https://arxiv.org/abs/2610.29162

## The question

Many readers feel that text from recent AI models has become harder to understand. The authors test two hypotheses:

- **H1.** The output of frontier and near-frontier models overuses linguistic features that are linked to comprehension difficulty in people.
- **H2.** Pressure toward information density during post-training makes the output of models less humanlike.

They find support for both.

## The features they measured

Psycholinguistic research links each of these features to slower or harder reading. For each one, the authors also explain why a push to pack information into fewer tokens might favor it.

| Feature | Example | Why it is hard for people | Why compression might favor it |
| --- | --- | --- | --- |
| Rare word pairs and high n-gram perplexity | "verified red", "reader-patience budget" | Unpredictable words take longer to read (Hale 2001; Levy 2008; Smith and Levy 2013). | Common, predictable words carry little information, so a dense writer skips them. |
| Long dependencies | "The guitar sitting in the corner because you're still 'deciding' teaches you zero chords." | Related words that sit far apart strain working memory (Gibson 1998, 2000), and people tend to avoid them (Futrell et al. 2015). | Not argued separately. |
| Object relatives, with and without "that" | "the behaviour (that) the old code never reached" | They are harder than subject relatives, partly because of word order and longer dependencies (Staub 2010). | They are shorter than the passive alternative, and leaving out "that" saves another word. |
| Stacked nouns (three or more) | "class-time shutdown requirement" | The grouping is ambiguous ("Squad Helps Dog Bite Victim"), and new compounds slow reading (Staub et al. 2007). | A stack packs a specific meaning into few words. |
| Nouns used as verbs | "calendar it" | The change of word class makes readers reanalyze the sentence (Thierry et al. 2008). | "Calendar it" is shorter than "put it on your calendar". |
| Inanimate subjects with verbs that need a person | "`is_file()` swallows that" | Readers use animacy to parse, and a mismatch triggers reanalysis (Trueswell et al. 1994; Kim and Osterhout 2005). | "Bites" can stand in for "causes an issue". |

The authors find all of these by parsing the text with spaCy. For nouns used as verbs and for inanimate subjects, an automated classifier then judges each candidate.

## The data

- **Models.** Fourteen in total. The nine frontier or near-frontier models were Claude Sonnet 5, Claude Opus 5, Claude Opus 5.5, Claude Fable 5, GPT-5.6 Luna, Terra, and Sol, GLM-5, and Kimi K2.5. The five smaller open models were Llama 3.1 8B (base and Instruct) and Olmo 3 7B (base, Instruct, and Think). All models ran under the same agent harness and the same prompts.
- **Chat.** Ten conversation topics, 12 turns each, with a simulated user, for 120 conversations and 1,428 replies.
- **Coding.** Each frontier model was asked to find and fix bugs in five real GitHub repositories, for 45 sessions in total. Only the last message of each turn was analyzed, which is usually a summary of the work.
- **Essays.** Seven assignments from the PERSUADE 2.0 corpus, ten essays per model per assignment, for 980 essays. The human comparison was 2,934 student essays with high scores on the same assignments.
- **Human baselines.** OpenSubtitles for chat, StackExchange for coding, the student essays for essays, and Wikipedia.

The whole collection cost $251.19 in API fees.

## The method: paraphrase by round-trip translation

To separate a model's choice of wording from what it means, the authors translated every sentence into Japanese and back into English with NLLB-200. Translation keeps the meaning and replaces the wording with more common forms. If a feature becomes rarer after the round trip, the model chose it over an available alternative. They repeated the check with a Russian pivot and with a second translator.

## What they found (H1)

- **Compared with paraphrases of the same content,** frontier models overused rare word pairs, nouns used as verbs, inanimate subjects, and object relatives without "that". They underused object relatives with "that", which suggests a preference for skipping optional words. In chat and coding, the same held for stacked nouns and dependency length, but not in the essays.
- **Compared with human writing,** all nine frontier models used more inanimate subjects with verbs that need a person, and more rare word sequences. In conversation, most also used longer dependencies, more stacked nouns, and more object relatives without "that".
- **The setting matters.** The effects were smaller in single essays than in multi-turn chat and coding. The authors suggest that long back-and-forth exchanges may push models toward compression.
- **The model matters.** The Llama models changed least under the round trip, and so did the base and instruction-tuned Olmo models. Olmo Think, a reasoning model, looked like the frontier models: within the Olmo family, the effects grew from the base model to the instruction-tuned model to the reasoning model. Claude Opus 5.5 scored lower than Claude Opus 5 on 19 of 21 comparisons of the difficulty measures.

## The mechanism (H2)

The authors fine-tuned a small open model (Qwen2.5-1.5B-Instruct) with reinforcement learning (GRPO). Its task was to turn a structured event description into one English sentence. The reward was correctness minus a penalty for each token. Every event could be expressed with either form of a short-or-long choice, for example "He sent us a photo" or "He sent a photo to us".

- The more the training penalized length, the more often the model chose the shorter form.
- Without a constraint that kept it close to the original model, any length penalty drove every run to choose the short form almost always. For the two trained "that" constructions, the short form appeared more than 98 percent of the time.
- The preference spread to "that" constructions that the model never saw in training, "sure (that)" and "so (that)". Among four unrelated constructions, only the genitive shifted, and only without the constraint.
- People use both forms and choose by context. For example, they include an optional "that" more often when what follows is harder to predict (Levy and Jaeger 2007; Jaeger 2010).

The authors' interpretation: training with verifiable rewards scores whether an answer is correct, not whether a person can follow it. Training on human feedback tends to reward longer outputs (Singhal et al. 2024), so the pressure toward compression is more plausibly tied to verifiable rewards. Models may drift toward a dialect that is good for packing information densely but hard for people to read. The authors add that models can also be rewarded for communicating well, and that Claude Opus 5.5 shows a measurable improvement over Claude Opus 5.

## Limitations

The authors list these:

- They studied a subset of models, only in English, with a limited number of chat topics and code repositories.
- Proving the cause in frontier models would require studying them during post-training, which is not feasible at scale, so they rely on proxies.
- Limited compute constrained the post-training experiment.

Two more points matter when you turn the findings into writing advice:

- The study measured features that earlier research links to difficulty. It did not test how quickly or how well people understood the AI-generated text itself.
- The findings are statistical. A single object relative without "that" is not a mistake. The pattern becomes a problem when a writer chooses the dense form every time.

## From the study to the skill

| Study feature or finding | Rule in SKILL.md |
| --- | --- |
| Long dependencies | 1. Keep each subject close to its verb |
| Stacked nouns | 2. Don't stack nouns |
| Object relatives without "that" | 3. Mark relative clauses |
| Optional words dropped under a length penalty | 4. Keep the small words that show structure |
| Nouns used as verbs | 5. Use ordinary verbs |
| Inanimate subjects with verbs that need a person | 6. Give human actions to people |
| Rare word pairs | 7. Use common words in their usual combinations |
| Information density in the background research | 8. Give each sentence one main idea |
| Stronger effects in long chats and coding sessions | "When to take extra care" |
| People choose between forms by context | "Don't overcorrect" |
```

## File: LICENSE
size: 1074
sha: a0ec1cb592e2bfcbd37f257af23d925b4630e570
upstream: https://github.com/hsheimbuch/understandable/blob/HEAD/LICENSE

```text
MIT License

Copyright (c) 2026 Heinrich Heimbuch

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
```