AI writing policy for engineers: the template and 5 checks

TL;DR

An AI writing policy for engineers works when it governs accountability and output quality, not tool use — a ban on model-assisted drafting is unenforceable because you cannot tell from a finished paragraph what produced it. Clay's version, published by Sophie Alpert in June 2026, is four rules resting on one claim: there are no lossless transformations of natural-language text, so a rewriter who does not know what you meant will drop something. Below is the whole policy in five lines plus the five reviewer checks that make it enforceable.

Simon Willison linked Alpert's post on 11 August 2026, which is how most engineers found it. The piece is short. The policy behind it is the transferable part.

What is an AI writing policy for engineers?

An AI writing policy is a set of rules about what a document must be true of when it ships — not a set of rules about which tools produced it. That distinction is the whole design.

Tool-level policies fail for a mechanical reason: they are unverifiable. You cannot look at a paragraph and know whether a model wrote it, and detector tools guess. So a rule phrased as "don't use AI for design docs" degrades into a rule about not getting caught, which is worse than no rule, because it removes the honest disclosure you actually wanted.

Output-level policies are checkable. "You must be able to defend every sentence" is something a reviewer tests by asking a question in a comment thread. "The document must be shorter than the work that went into it" is something a reader notices. Neither requires knowing what tool was open.

Alpert, an engineer at Clay who previously worked on React, Humu and Notion, published the rationale on 25 June 2026. Her central claim is worth quoting exactly, because the policy is downstream of it:

There are no lossless transformations of natural-language text — every rewrite and rephrase changes the meaning of your writing, and if this is done by an entity that doesn't have the most detailed mental representation of what you personally were trying to communicate, information will be lost.

The mechanism: what a rewrite actually drops

The claim sounds philosophical. It is not — the losses are specific and you can name them.

Your intent is richer than your draft. The draft is already a lossy encoding: you chose an ordering, a hedge, an emphasis. A model rewriting that draft has the draft and nothing else. It does not know that you put the caveat in sentence two because your staff engineer will object at exactly that point, or that "we should probably" was doing careful load-bearing work about how confident you actually are.

A commenter on the Hacker News thread gave the cleanest illustration of how little it takes. Take "She said she did not take his money." Stress a different word each time and you get eight different meanings out of one identical string — who said it, whether it was said or implied, whether she took something else, whose money. Prose carries that emphasis structurally, through word order and sentence shape, and a rewrite that smooths the sentence for readability destroys it without leaving a trace that anything was there.

Four categories cover most of it:

Engineers already know this shape from the machine side. Agent context compaction is the same transformation with the same failure mode — a summariser that does not know which of the last 150K tokens you will need next drops the wrong ones, confidently, and the trace looks clean afterwards. Human writing is that problem with worse instrumentation, because there is no usage field to check.

The four rules, and what each one prevents

Alpert's policy is four principles. Read them as failure modes with a rule attached, which is how they end up being reviewable.

1. You own every sentence. In her wording: "You must stand behind every idea and every sentence in your docs. It is your responsibility to make sure that the entire document is representative of your own thoughts before you share it." The enforcement is the corollary Willison highlighted — when someone asks about a line, "AI wrote that, just ignore it" is not an available answer. That response confuses the reader and wastes the time they spent taking your document seriously.

2. Writing is how the thinking happens. A tech spec or a retrospective is partly an artifact and mostly evidence that someone did the reasoning. Outsource the drafting and you skip the step where you discover your design does not work. The document still exists; the thinking it was supposed to force does not.

3. The author spends more than the reader. Effort is asymmetric — you pay writing cost once and reading cost is multiplied by your audience.

4. Length is a cost, not a signal. Alpert cites Pascal: "I have made this [letter] longer than usual because I have not had time to make it shorter." Model output trends verbose, and the specific damage is vacuous sentences that read as content while carrying none, which makes the real points harder to find rather than merely making the document longer.

One deliberate exception runs through all four: quoting a model verbatim is fine when it is marked as a quote — "Claude offered this idea, do you think it's worth exploring?" is honest and useful. The policy targets unmarked laundering of model output as your own reasoning, not the model's presence in the room.

Rule 3 has arithmetic behind it

The effort-asymmetry rule is the one people treat as a platitude, and it is the one with a number in it.

Model it directly. Say a careful document costs the author 60 minutes and takes each reader 2 minutes. Say the padded version costs the author 15 minutes — the model did the expansion — and takes each reader 3.5 minutes, because the content is now spread across filler. Total team cost is 60 + 2N against 15 + 3.5N for N readers.

Those lines cross at N = 30. Below thirty readers the fast draft is genuinely cheaper for the organisation. Above it, every additional reader pays 90 seconds so the author could save 45 minutes, and by 60 readers the team is 45 minutes down on a single document.

Those inputs are assumptions, not measurements — substitute your own and the crossover moves. What does not move is the shape: author cost is a constant and reader cost has your headcount multiplied into it. For an RFC that goes to the whole engineering org, the crossover is somewhere near zero readers and conciseness is not a preference. For a scratch doc two people will read, it genuinely does not matter, and a policy that pretends otherwise will be ignored on exactly the documents where it is right.

The policy, in five lines

Here is the whole thing, short enough to paste into a handbook page. Adapt the wording; do not add tool clauses to it.

AI writing policy. You may use AI to brainstorm, draft and proofread.

1. You stand behind every idea and every sentence you ship. "The AI wrote that" is not an answer to a question about your document.
2. If a document exists to show reasoning — a spec, a retrospective, a proposal — you do the reasoning. The document is evidence of it, not a substitute for it.
3. Spend more of your time writing than your readers will spend reading, multiplied by how many of them there are.
4. Length is a cost. Cut anything that does not carry a claim.
5. Verbatim model output is fine when it is marked as a quote.

Five lines is the point. A policy long enough to need its own summary has already failed rule 4, and nobody reads the appendix that governs their writing.

How do you review a document under this policy?

The policy is only real if reviewers act on it. Five checks, none of which require guessing whether a model was involved:

1. Ask one "why not the alternative" question about a specific claim in the document. An author who did the thinking answers in a sentence. An author who did not will either go quiet or produce a fresh paragraph of plausible reasoning, which is itself the answer.

2. Check that every number has a source. Unsourced specificity is the highest-signal defect in model-assisted prose, because plausible numbers are exactly what a language model is good at producing.

3. Check length against content. If you can cut 30% without losing a claim, the document failed rule 4 — send it back rather than editing it yourself, because editing it yourself moves the thinking to you permanently.

4. Check that quotes are marked. Verbatim model output presented as the author's reasoning is the one thing the policy actually bans.

5. Check the document answers the question it was opened for. A restructure — by the author or a model — routinely leaves a document that is well-organised around the wrong axis.

The same discipline pays off in the machine-facing direction too: writing instructions a model will follow and tool descriptions an agent can act on both fail in the same way, where prose that reads fine to a human turns out to have dropped the one distinction that mattered.

Common mistakes

Writing the policy as a tool ban. Unverifiable, so it becomes a rule about disclosure rather than quality, and you lose the disclosure too.

Adding an AI-detector step. Detectors have false positives on non-native English speakers and on anyone with a clean prose style, and the question they answer is not the one you care about. A well-reasoned document with a model in its history is fine; a badly reasoned one written entirely by hand is not.

Requiring an "AI-assisted" label on everything. It sounds rigorous and it collapses immediately, because nearly everything qualifies once autocomplete counts. Reserve marking for verbatim quotes, where it carries information.

Applying it to code review unchanged. The ownership rule transfers directly — you own the diff you opened. The conciseness rule does not; explicit code beats clever short code. Pull request descriptions and commit messages, though, are prose read many times by many people, so rule 3's arithmetic applies to them harder than to almost anything else.

Skipping the writing step on specs. This is rule 2, and it is the expensive one. A spec produced without the reasoning is a document that looks like a decision was made. Spec-driven development with agents only works when the spec encodes real decisions — a generated one just relocates the ambiguity downstream, where it costs more.

The objection worth taking seriously

The Hacker News thread on Alpert's post — 31 points and 11 comments, so a small one — landed the strongest counterargument early: "lossless" is a compression term and applying it to natural language is close to circular, since human-to-human communication is not lossless either. Every reader reconstructs meaning from their own context. A rewrite by a colleague loses information too.

That is correct, and it does not rescue the practice. The relevant comparison is not "AI rewrite versus perfect transmission" but "AI rewrite versus your own draft". Your draft was written by the one entity with access to your intent. Every subsequent transformation by something without that access is strictly downhill on the dimensions above — and unlike a colleague's edit, it arrives with no diff, no rationale, and no one who can be asked why.

The second objection is more practical: generated documentation from code context is often good enough for its audience. Also true, and it marks the boundary. Reference material where the source of truth is the code — API surfaces, config tables, changelogs — is a legitimate generation target, because there the code is the intent and the doc is a projection of it. Documents whose value is the reasoning — specs, retrospectives, proposals, incident write-ups — are the ones the policy is for. Confusing the two categories is how teams end up with a policy nobody follows.

Conclusion

The rule that does the work is the first one: you own every sentence, and "the AI wrote it" is not a defence. Everything else follows, including the conciseness rule, because an author who genuinely has to defend each line stops shipping lines they cannot.

Write the policy about the document, not the tool. Give reviewers the five checks. And accept that the mechanism underneath is real even if the compression metaphor is loose — a rewriter without your intent will drop something, and you will not find out which thing until the reader acts on the version that survived.

Next: what a summariser drops when it compacts your agent's context — the same loss, with metrics attached.

Frequently asked questions

What should an AI writing policy for engineers actually cover?

It should cover accountability and output quality, not which tools people are allowed to open. A policy that says "no AI in docs" is unenforceable and gets ignored within a quarter, because you cannot tell from a finished paragraph whether a model touched it. The rules that hold are the ones a reviewer can check against the document itself: the author stands behind every sentence, the document is shorter than the effort that went into it, and any verbatim model output is marked as a quote.

Is it true that there are no lossless transformations of natural-language text?

As a practical claim about rewriting, yes. Sophie Alpert's formulation is that every rewrite and rephrase changes meaning, and when the rewriter lacks a detailed mental representation of what you were trying to communicate, information is lost. Critics on Hacker News argued the claim is definitionally circular, since human-to-human communication is not lossless either. That objection is fair and does not change the operational consequence: a model rewriting your draft cannot preserve a distinction it never knew you were drawing.

Can engineers use AI for drafting and brainstorming under this kind of policy?

Yes. Clay's policy explicitly permits brainstorming, drafting and proofreading with a model. What it removes is the ability to disclaim the result — you own every sentence that ships under your name, whatever produced the first version of it. The practical effect is that AI moves from a writing shortcut to a thinking aid, which is where it is actually good.

Why does an AI writing policy say the author should spend more time than the reader?

Because writing cost is paid once and reading cost is paid per reader. If padding a document saves the author 45 minutes but adds 90 seconds for each of 60 readers, the team loses 45 minutes net on that one document. The asymmetry is why conciseness is a policy rule rather than a style preference, and it is also why verbose model output is expensive even when it is accurate.

How do you review a document you suspect was AI-generated?

Do not try to detect the model — detectors are unreliable and the question is unanswerable from the text. Review for the failure modes instead: ask the author a "why this and not the alternative" question about a specific claim, check that every number has a source, and check that the document's length is justified by its content. An author who cannot defend a paragraph they shipped has failed the policy regardless of how the paragraph was produced.

Does an AI writing policy apply to code and commit messages too?

The accountability rule does, and it is the one that transfers cleanly: you own the diff you open a pull request for, including the parts a model wrote. The conciseness rule mostly does not apply to code, where explicitness often beats brevity. Commit messages and pull request descriptions sit with prose — they are read many times by many people, so the author-effort-exceeds-reader-effort arithmetic applies to them directly.

Sources

• Sophie Alpert — There are no lossless transformations of natural-language text, 25 June 2026 (the four principles, the ownership quote, the Pascal citation, and the marked-quote exception)
• Simon Willison — There are no lossless transformations of natural-language text, 11 August 2026 (the "AI wrote that, just ignore it" enforcement point)
• Hacker News — discussion thread, 31 points / 11 comments (the eight-meanings stress example and the circularity objection)

Originally published at umesh-malik.com

Keep reading on umesh-malik.com:

• Developer Productivity Tools for Senior Engineers
• Rust LLM Policy: Use AI to Review, Not to Create
• Agent-to-Human Delegation: Why Your AI Shouldn't DM Coworkers