AntiGPT

Humanize AI-drafted technical documentation

AI is a useful first drafter for documentation and a dangerous final one: it produces smooth prose that is often subtly wrong, and it loves to pad. For docs, humanizing serves a slightly different goal than elsewhere: not disguising the machine, but making the writing clear, consistent, and human to read while you guarantee it is correct. Basic mode is usually right: it tightens prose without touching your structure.

Correctness is the whole job

Documentation is judged on whether it works, not on how it reads. A humanizer must never alter a command, a flag, a path, a parameter name, or a code sample, so keep those out of the rewrite entirely. Paste the prose around a code block, humanize it, and leave the code exactly as it is. After any rewrite, verify that steps still work in order and that no instruction was smoothed into ambiguity ('run the command' is worse than 'run npm install').

Treat the tool as a copy editor for the connective prose, not as an author of the technical content. The value is a page that reads clearly and consistently; the responsibility for accuracy stays entirely with you.

What Basic mode fixes in docs

AI-drafted docs over-explain, repeat the heading in the first sentence, and hedge where they should be direct. Basic mode cuts the padding and the throat-clearing while preserving your terminology and structure. The Standard readability setting keeps the register plain; avoid the higher-readability settings for docs, which can make instructions more elaborate than they should be.

Do it section by section. Documentation is read in fragments by people trying to solve a problem, so each section should stand alone and get to the point. Humanize one, verify it, move on.

Consistency across a doc set

A documentation set should sound like one voice and use one term for one thing. Pick a strength and readability and hold them across pages, and keep a short glossary of the exact terms your product uses so a rewrite never swaps 'workspace' for 'project' or 'token' for 'key'. Where a term is load-bearing, check it survived the rewrite.

Run the detector if you want a read on how templated the prose sounds, but for docs the real acceptance test is a colleague following the steps on a clean machine and reaching the end without getting stuck.

Release notes and READMEs

Short-form docs (release notes, READMEs, error messages) benefit most: they're where machine padding is most obvious and most annoying. Humanize them to be short and direct, keep version numbers and commands exact, and lead with what changed for the reader rather than with a summary of the summary.

A worked example

Before

In order to successfully authenticate with the API, it is necessary for you to first obtain an API key. Once you have obtained your API key, you will then be able to include it in the header of your requests in order to gain access to the various available endpoints.

After

To use the API you need an API key. Create one in Settings → API, then send it as the Authorization header on every request: Authorization: Bearer YOUR_API_KEY Requests without a valid key return 401.

The padding is gone, the step is concrete (where to create the key), the code is preserved exactly, and the failure case is stated. Basic mode tightened the prose without inventing anything.

Try it on your own text

Recommended strength for this use: Light. Free plan: 300 words a month.

Input

or try a sample:
0 / 300 words

Humanized

Your humanized text appears here

Detector scores are estimates from third-party classifiers and change as those tools update. No text can be guaranteed to pass any detector. Use this to improve your writing, and follow your institution's or employer's rules on AI use.

Questions

Will it break my code samples or commands?

Not if you keep them out of the rewrite: humanize the prose around code blocks and leave the code, flags and paths exactly as they are.

Which setting for docs?

Basic with Standard readability. Avoid higher-readability settings, which can make instructions more elaborate than they should be.

How do I keep terminology consistent?

Hold one setting across the doc set and keep a short glossary; check that load-bearing terms survived each rewrite.