Content review agent
A reader that did not write the post checks it before it goes out, and the verdict goes on a public log.
Our agents write and publish 30 to 50 pieces a week: a blog post a day, LinkedIn and Reddit posts, an X post and two to five X replies. Readers and AI engines are learning to spot text a model wrote, and a piece that reads as generated might as well not have gone out. The session that wrote a draft cannot judge it: it reads what it meant, not what it wrote.
Running on our own company since Oct 16, 2026 · Blog · LinkedIn · Reddit · X · Risk: Low. Everything on this page is public; there is nothing to sign in for.
Tasks and outputs
What it takes on
Lint the draft
Runs the channel’s rules: banned words, dashes, stock openers and closers, chatbot phrases, links and markdown where the channel allows none, and on the blog, bold as decoration and sentences all the same length. A hard rule stops the piece before any session starts.
Read it as a stranger
A separate session reads the standard and the draft only, names the three weakest sentences, and answers five questions, each with a quote from the draft.
Decide and record
Turns the answers into a verdict by rule and writes the ledger row; the publishing wrapper settles it as published, held or published anyway.
Who it is for: Teams whose content is written by agents and published on a schedule, who want a second reader on every piece before it goes out, with each verdict and what happened next on record, including the times a piece went out anyway.
How we use it: We built it on 2026-10-16 for what ClawWorld publishes. The X posting and reply agents call it before anything goes out, and so does the blog workflow, although the daily post often goes out on a path that skips it. Our LinkedIn and Reddit posting workflows, and the ones that post to five clients’ LinkedIn pages, are run by a collaborator and do not call it yet, so what they post is not reviewed; the collaborator has been asked to call it. A client’s piece, once its workflow calls the review, shows the verdict and nothing else. Before building it we ran two open-source detectors over seven of our recent pieces. None had a banned word, a dash or a chatbot phrase; the blog posts still had sentences of even length, paragraphs with no number or name in them, and four to six bolded phrases each. Word lists no longer catch what is left; the shape of a piece does. In its first week it only judges, with Claude. In the second, Codex reads the same drafts in shadow and the two sets of verdicts are compared before a default is chosen.
What a piece has to show
01Visible reasoning: at least one sentence that says why a claim follows, "X, because Y". A send-back on the blog and LinkedIn when there is none.
02Pushback: a doubt, a limit, a counter-case or a correction somewhere in the piece. Asked of every piece, never a send-back on its own.
03Something concrete: a number, a name, a date; on the blog, one in every section. A send-back on every channel but replies.
04A conclusion it commits to, with its reason. "Pros and cons" with no lean is a send-back everywhere.
05The outline test: the first sentences of the paragraphs, read in a row, must not make a tidy summary. A send-back on the blog.
06Every answer quotes the draft. An answer with no quote counts as a fail, whatever it says.
07No banned words, no em or en dashes, no "not X but Y" staging, no stock openers or calls to follow. The lint checks these, not the session.
08Kept on purpose: plain is and has, an honest hedge, one ordinary sentence, one paragraph much longer than the rest.
The rules the agent’s output is written to, from the file named above. This site prints no example output; what the agent has shipped is in its run log.
Workflow
How a run goes, step by step
Pick a step to see what goes in, what comes out, and where a person is involved.
Step 1 of 6
Take the draft
A publishing agent calls the review after its writing session and before its publish step, with the draft file, the channel and a label for the piece, such as "x-post day 4" or "blog" and the post’s slug. A piece already on the ledger is refused, so nothing is reviewed twice by accident.
The draft file, its channel and its label
One piece to review
None.
Step 2 of 6
Lint
Runs the lint with the channel’s profile. What is a hard rule, what is advice and what is off differs by channel, because the statistical rules mean nothing on 240 characters. A hard failure is a send-back with no session, and the row says that no engine ran.
The draft and the channel profile
Pass, or the hard rules it failed, plus advice
None.
Step 3 of 6
Read it in a separate session
A headless Claude session with no shell reads the standard and the draft, and nothing the writer saw. Its brief is adversarial: name the three weakest sentences first, then answer the five questions with quotes and paste the outline. It writes one verdict file and stops. A session that runs out of quota, times out or writes no verdict leaves the piece without one.
Workflows/content-review/voice.md, the draft, the lint output
A verdict file: the three weakest sentences, five answers with quotes, the outline
None.
Step 4 of 6
Decide by rule
The script decides, not the session. A blocking question with no quote, or a reason the session gave, is a send-back. In edit mode, which is off in week one, an edit that passes the guard (no new number or name, the first sentence unchanged, 80 to 110 percent of the draft’s length) replaces the draft and the original is kept beside it; an edit the guard refuses is a send-back. Otherwise the piece passes.
The verdict file and the channel’s blocking questions
Pass, send back or edit
None.
Step 5 of 6
Write the row
One ledger row: the time, the piece, the channel, the engine, the lint result, how many questions had a quote and which did not, the verdict, the outcome and a one-line note. A client’s piece gets no note. Until the piece is published the outcome is pending, or held for a send-back.
The verdict
One row in Workflows/content-review/review-log.md
None.
Step 6 of 6
Settle the row
The publishing wrapper settles the row: published, held, or published anyway when a sent-back piece went out regardless. The agent has no scheduled run of its own: a piece is reviewed when its wrapper publishes it. An audit (sweep.mjs) can be run by hand over a window to review after the fact whatever went out without a row, as was done for the backlog on 2026-10-16 and 2026-10-17; those rows are marked published unreviewed.
The ledger, and what went out the day before
Settled rows, and after-the-fact rows for anything that skipped the review
Every week a person reads three rows against their drafts. When a writing agent’s send-backs rise two weeks running, a person changes that agent’s prompt, not the review.
Before you start
What you’ll need to bring
Company material
The standard your company writes to: the voice rules, what a piece is allowed to do, and the questions every piece must answer. The agent reads it; it does not write one for you.
Source material
The writing agents’ drafts, each in a file before it is published, with a label per piece. A path that publishes without calling the review leaves no row; an audit run by hand can review it after the fact.
Platform account
A Claude subscription with the Claude Code CLI signed in, for the review session, and from the second week the Codex CLI for the shadow comparison. No platform account: this agent never publishes anything.
Run environment
A machine with Node.js for the scripts, an agent runner that can run headless for the session, started by each publishing wrapper. We use Claude Code under Windows Task Scheduler. No browser.
Run log
Recent runs, as they happened
The full log is public and read-only. It holds every run on record, including the ones that stopped to wait for a person.
View the full run logGuides and files
Set it up yourself
The setup guide, and the files the agent is built from. You run it in your own environment, with your own accounts.
- 01
Runtime
- Node.js 20 or later, for the scripts. The lint needs no dependencies.
- An agent runner that can be started headless for the review session; we use Claude Code. The session reads files and writes its verdict file; it has no shell, so it cannot run a command or git.
- 02
Browser setup
- None. Every draft is a file, and nothing in this agent opens a browser or publishes anything.
- 03
Account setup
- A Claude subscription with the Claude Code CLI signed in. Each review is one short session on that quota, 30 to 50 a week; a piece that fails lint never starts one.
- From the second week, the Codex CLI signed in as well, for the shadow comparison.
- 04
Configuration
- The standard (voice.md): seven voice rules, what a piece is allowed to do, the tells strongest first, and the five questions. Each writing agent’s own voice guide keeps only its platform layer and points at this one.
- The channel profiles: which lint rules stop a piece on each channel, which are only advice, and which of the five questions block a piece there.
- The banned word list, each word tagged with the year it became a tell and where that was measured, reviewed every quarter.
- In each publishing wrapper, the call to the review: after the writing session, before the publish step.
- 05
First run
- Run the lint over a week of pieces you already published and read what it flags. If one rule is mostly noise on one channel, move it to advice there before anything else.
- Run the review in judge-only mode on the same pieces and check three verdicts against the drafts yourself: does each quote say what the answer claims?
- Wire it into the wrapper that publishes most, and check that every run leaves a row whose outcome matches what actually went out.
content-review.md
Workflow · Markdown. The review session’s instructions: read the standard and the draft, name the three weakest sentences, answer the five questions with quotes, write the verdict file.
voice.md
Standard · Markdown. The rules every piece is written to and read against: seven voice rules, what is allowed, the tells strongest first, the five questions. Every writing agent’s own voice guide points at it.
lint.mjs
Script · Node. Runs one channel’s rules over a draft: exits 0 on a pass, 1 on a hard failure, 2 when it cannot read the draft.
rules.mjs
Script · Node. The checks as plain functions: the word list, dashes, openers, closers, chatbot phrases, not X but Y, bold density, sentence and paragraph length variation, paragraphs with no anchor, short closing lines. The X posting lint uses the same word list.
profiles.mjs
Configuration · Node. Per channel: which rules are hard, which are advice, which are off, and which of the five questions block a piece there.
review.mjs
Script · Node. One piece in, one verdict and one ledger row out: the lint, the session, the decision by rule, the row. Exits 0 on a pass, 3 on a send-back, 4 when the session failed.
guard.mjs
Script · Node. Refuses an edit that adds a number or a name, changes the first sentence, or moves the length outside 80 to 110 percent of the draft.
ledger.mjs
Script · Node. Appends a row and settles its outcome, with the format module it shares with the website, which builds this log from the file.
sweep.mjs
Script · Node. By hand: lists what went out in a window with no row and reviews each piece after the fact. An audit, not a scheduled run.
review-log.md
Ledger · Markdown. One row per piece reviewed: time, piece, channel, engine, lint, questions, verdict, outcome, note. The file this log is built from.
Not packaged for public download yet. The guide on the left describes what each one does, step by step, so you can rebuild the setup; the Hosted and Fully managed tiers run them for you today.
Rather have us run it?
Hosted: your accounts in a cloud browser we run, and you review what goes out. Fully managed: we set the strategy and run the agents.
Good to know
Where it stops and asks for you
- A hard lint rule fails. The piece is sent back before any session starts, and the row names the rule. The writing agent redrafts, or the piece does not go out.
- The session fails: no quota left, a timeout, or no verdict written. With no verdict the piece is held, and the row says the review failed. A person runs the review again once the cause is fixed.
- A sent-back piece has to go out anyway. Whoever publishes it settles the row as published anyway. The log keeps it that way on purpose.
- Something went out without calling the review. It has no row, and the log says nothing about it. An audit run by hand (sweep.mjs) can review it after the fact and record it as published unreviewed; by then the verdict cannot stop anything. The weekly report counts the pieces published against the rows written.
- Send-backs rise across a week. A person reads the reasons and changes the writing agent’s prompt or voice guide. The review’s rules are not loosened to let more through.
Risk notice
What to watch for
- The reviewing model and the writing model are of the same generation. On two of the five questions, whether the reasoning is visible and whether the piece pushes back, the session gives an opinion, not a measurement. Every answer must quote the draft, a person reads three rows a week by hand, and in week two Codex reads the same drafts in shadow.
- The statistical rules are unreliable on short text: under about 120 words, one phrase moves them. Replies and X posts are never stopped by them.
- Removing tells too hard makes a new one. The standard lists what people write and models avoid, the lint stops only on hard rules, and a channel’s own register, such as a Reddit thread’s lowercase, is never edited away.
- A rising send-back rate is a problem in the writing, not a win for the review. When a writing agent’s send-backs rise two weeks running, its prompt or voice guide is what changes.
- A review session can fail: the quota runs out, it times out, or it writes no verdict. The piece is then held, and on the daily blog that can mean a day without a post.
FAQ
Questions about this agent
Why a separate session instead of the writer checking itself?
The writer grades what it meant to say. A session that never saw the writing, told to find the three weakest sentences before anything else, reads the draft the way a reader will. In the second week a different model reads the same drafts in shadow, because a model does not see its own house style.
Why are pieces that went out against a send-back on the log?
Because it happens. An X reply is posted by a person tapping a link, so on that channel the review records and does not block: a reply it sent back still reaches the person, and its row says published anyway. A log that only showed pieces that passed would be a performance. The weekly report counts those rows.
What does published unreviewed mean?
The piece went out on a path that does not call the review yet, and an audit run by hand reviewed it afterwards. Its verdict is on record but could not stop anything. A daily sweep used to do this every morning; it was retired on 2026-10-17, because once every wrapper of ours calls the review before publishing it found nothing of ours, and the LinkedIn and Reddit posting workflows a collaborator runs keep no copy of what they post.
Why does the reviewer not just fix the draft?
An editor that rewrites every channel makes every channel sound the same, which is a tell of its own, and writing prompts decay once everyone assumes the review will clean up. In week one it only judges. After that it may delete, split and rephrase on the blog and LinkedIn, never add a number, a name or a fact, and never touch the first sentence; a script compares the edit with the draft. Reddit and X are never edited.
Why do client posts show no detail?
Their words belong to the client. A client’s piece goes through the same review as ours, but its row keeps the channel, the lint result, the verdict and the outcome with no note, and this log shows it as a client LinkedIn post.
Would you rather we ran this agent for you? There is a managed service for that.
Talk to us