Draft in Claude, score, then publish: a content workflow with a voice gate

By Jack Stovell · 2026-09-27 · Guides

Draft in Claude. Score the draft against your measured profile. Polish anything under 0.85. Save the edit. Publish. That's the whole loop, and it runs over MCP with the scoring free every time. No credits burned checking your own work.

Method box: scoring measures counted features (sentence length, contractions, commas, pronoun mix, and more) plus judged features (formality, humour, rhythm, argument structure) against your profile, weighted and calibrated to a 0 to 1 band. Full method at /reference/voice-measurement-framework, checked 2026-09-20.

The workflow in one paragraph

Here's the thing: most content workflows treat voice as a vibe check at the end. This one treats it as a gate in the middle. You connect a profile, draft in Claude with that profile attached, score what comes back, polish anything that misses, save the winning edit, and publish. Four tool calls, one loop: `create_profile`, `generate_content`, `check_voice_match`, `save_edit`. Nothing exotic. The whole thing works over MCP inside Claude, so there's no copying scores between tabs.

Connect the profile

You start with `create_profile`, or `list_profiles` if you've already built one. A profile is 1 to 20 writing samples, 50 to 5,000 words each, sent via `POST /v1/profiles`. It comes back `processing`, so you poll `GET /v1/profiles/{id}` until it's done. What lands is a narrative description, a confidence score, and a 45-attribute object covering everything from sentence variance to article balance (the a/an/the ratio, which sounds trivial until you see how consistently it marks a voice).

This isn't a prompt export. It's a live object the model reads at generation time, through MCP or the REST API directly. That matters later, because the same profile can travel to other tools without you rebuilding it each time; see one voice profile, every tool for why that's the point.

Draft in the voice, or draft and score

Two ways to run this. Either `generate_content` with the profile attached from the start, so Claude drafts already leaning into your rhythm, or draft loosely and run `check_voice_match` after, to see how far off bare Claude sits from you.

The second option is the more honest test. `POST /v1/voice-match` takes a profile ID and 20 or more words of text, and returns a `voice_match_score` from 0 to 1, notes, and per-feature deltas. It's free, so there's no reason not to run it on everything, including drafts you already suspect are fine. SGR-001 ran this exact comparison on a banking brief: bare Claude averaged around 17 words a sentence, a measured voice profile pulled that to about 11. Sentences under eight words doubled, from 24% to 48%. Contractions rose by roughly 70%. Ten em dashes became none. One run each, unedited. That's the gap you're closing.

The gate: what to do under 0.85

The bands are simple. 0.85 to 0.95 counts as on-voice. 0.5 to 0.8 is partial: recognisably you, but drifting somewhere. Under 0.45 is off, meaning the draft reads like generic AI output wearing your name.

So what do you actually do with a 0.71?

Check the deltas first. `check_voice_match` doesn't just hand you a number; it tells you which features missed and by how much. If sentence length and contractions are off but formality and argument structure are fine, that's a polish job: `POST /v1/polish` nudges the draft toward a target score (0.9 by default) for 1 credit, and it's a free skip if the draft already clears the bar. If the deltas show the whole shape wrong (argument structure inverted, humour register absent, pronoun mix skewed), polishing won't save it. That's a rewrite: go back to `generate_content` with a sharper brief.

Weights matter here. Sentence length, contractions, formality, signature phrases, and banned terms each carry a weight of 2. Variance, commas, pronoun mix, confidence, humour, argument structure, and rhythm carry 1.5. A draft that's slightly too formal and slightly too long will drag the score down harder than one with a single stray semicolon. Know which levers move the needle before you spend a credit fixing the wrong one.

To be fair, sometimes 0.79 is fine. If you're drafting something meant to sit slightly outside your usual register, on purpose, don't force it to 0.9 just because the gate exists. The gate is a check, not a religion.

Save the edit, then let the memory work

Once you've settled on a final version, `POST /v1/generations/{id}/edit` saves it. This step is free, and it's not just housekeeping: it feeds the profile's learning, so future drafts start closer to what you actually kept, not just what the model first produced.

This is the step people skip, and it's the one that compounds. A profile that never receives edits stays static. One that does gets sharper with every piece you save, because the gap between "what Claude drafted" and "what you actually published" is exactly the signal the system needs.

What this looks like a month in

By ten or more saved pieces, the memory tools switch on. `check_novelty` tells you whether a new brief repeats an argument you've already made, before you spend a generation on it. `what_next` looks at what's indexed and suggests angles you haven't covered yet, which is more useful than it sounds when you're staring at a blank brief field. Generation with continuity carries forward what the profile has already argued, so a new piece builds on the last one instead of restating it; you can set the repeat policy to avoid or allow, depending on whether you want a series or standalone pieces that happen to share a voice.

All of this sits under `/v1/profiles/{id}/`, and all of it is free. That's worth sitting with for a second: the loop that catches drift, the memory that prevents repetition, none of it costs a credit. The only credits spent are on generation, polish (when needed), humanize (when needed), and the one credit per 1,500 words if you use `rewrite_page` to bring an old page into a new profile.

Compare that to running the same brief through a general-purpose model with no profile attached. SGR-002 tested exactly that: one author's five posts, two held back, a study profile built from the other three (2,447 words), each held-out post turned into a brief and run through GPT without the profile. The full comparison, including where GPT drifted and by how much, is at ChatGPT vs a measured voice. The short version: a profile that travels with you, that you keep feeding, beats a fresh context window every time you start one.

Questions

Does scoring cost credits?

No. `check_voice_match`, `compare_voice`, `ai_detect`, and everything under the memory endpoints (`check_novelty`, `what_next`, `get_memory`, `add_to_memory`) are free on every plan, including Free. Only generation, polish (when a draft doesn't already pass), humanize (same condition), `mimic`, and `rewrite_page` draw credits.

What score should I actually aim for before publishing?

Treat 0.85 as the floor, not the target. Above that, a piece reads as recognisably you across the counted and judged features alike. Between 0.5 and 0.8 it's salvageable with polish or a rewrite. Below 0.45, don't publish; the deltas will show you exactly what broke.

What's the difference between polishing and rewriting?

Polish nudges an existing draft toward a target score, useful when the deltas are narrow: sentence length, contractions, a stray banned term. Rewriting means going back to `generate_content` with a sharper brief, needed when the whole shape is off: argument structure, humour register, pronoun balance. Check the deltas before choosing.

How many samples does a profile need to start?

Between 1 and 20 samples, each 50 to 5,000 words. More samples generally sharpen the profile, but even a handful of solid pieces gives Claude enough signal to draft from. The confidence score returned with the profile tells you how stable the read is.

When do the memory tools actually kick in?

Once ten or more pieces are indexed under a profile, `check_novelty` and `what_next` start returning useful results, and continuity generation has enough history to build on rather than repeat. Below that threshold the tools still run, they just have less to work with, so treat the first ten pieces as building the memory, not testing it.