Diffusion text models: what actually changes for your work

Every chatbot you have used writes the same way: one token at a time, left to right, each word conditioned on all the words before it. That constraint is why long answers crawl across your screen, and it is why you have quietly built your whole working style around watching AI type. A different architecture is now shipping at real scale, and it does not have that constraint.

What actually changed

Diffusion is the technique behind AI image generators: start with noise, then refine it over several passes until a picture emerges. Applying the same idea to text means the model drafts the whole response at once in rough form, then improves many words in parallel across a handful of refinement passes, rather than committing to word one before it has any idea what word four hundred will be.

Inception, the lab behind the Mercury models, describes the difference plainly: in an autoregressive model "a token cannot be generated until all the text that comes before it has been generated," while their approach produces the answer "in a coarse-to-fine way" with a network that can "globally improve the quality of the answer by modifying multiple tokens in parallel" (Inception, Introducing Mercury).

The real numbers, with sources

This is the part that usually gets exaggerated in reels, so here are the published figures rather than the rounded-up versions. Every one of these links to the paper or the lab's own announcement.

1. ⚡ Mercury Coder: 1,109 and 737 tokens per second. Independently measured by Artificial Analysis on NVIDIA H100 GPUs for the Mini and Small models, which the paper describes as outperforming "speed-optimized frontier models by up to 10x on average while maintaining comparable quality" (Mercury technical report, arXiv).
2. 🚀 Seed Diffusion Preview: 2,146 tokens per second. ByteDance's research model, measured on H20 GPUs, reported as competitive with comparable models on code benchmarks (Seed Diffusion, arXiv).
3. 📦 DiffusionGemma: open weights, Apache 2.0. Released 10 June 2026, a 26B mixture-of-experts model that activates 3.8B parameters at inference, generating 256 tokens in parallel per forward pass, reported at "1000+ tokens per second on a single NVIDIA H100" and up to 4x faster generation than comparable models (announcement). This is the first time weights for a model like this have been openly downloadable.
4. 🧪 The research line is older than the news cycle. LLaDA showed a diffusion model trained from scratch could compete with autoregressive models of the same size back in early 2025 (Large Language Diffusion Models, arXiv). What changed in 2026 is that it left the lab.

Four things this is not

The reason this matters is real. The reason most posts about it are wrong is that speed gets confused with intelligence.

What near-instant text actually unlocks

Here is the part worth internalising. Right now, every AI workflow you build is silently designed around latency. You ask for one draft because three drafts would take three times as long. You do not ask the model to check its own work because you are not going to sit there for another ninety seconds. You accept the first output because the loop is slow enough to be annoying.

Remove most of that cost and the sensible design changes. A drafting step, a critique step and a rewrite step stop being a luxury and become the default, because all three finish in about the time one used to take. Agents can afford to try an approach, notice it is wrong and back out, instead of committing to their first plan. You stop babysitting the output and start reviewing finished work.

The workflow layer to build now

Four things, in order of how much they pay off. All of them work in any Claude today and none of them care which architecture is running underneath.

1. 📄 Write down your standard. The single highest-leverage artefact is a plain document that says what good output looks like for the thing you make most: the format, the tone, the things that are always wrong, and two real examples of your own work. Keep it in a Claude Project so every chat starts from it.
2. 🔁 Add a critique pass. Stop accepting first drafts. Make "draft, then critique against my standard, then rewrite" the shape of every request. This is the habit that gets dramatically cheaper as models get faster, so building it now means you are already positioned when it becomes free.
3. 🧩 Turn the repeated ones into skills. Once a process works twice, package it as a skill so you never re-explain it. In the app that is Customize, then Skills, then Add, then Upload a skill. It works on every plan including Free (official overview, how to create one).
4. 👥 Split the work across roles. A researcher, a drafter and a critic as separate agents beats one agent doing all three, because each one keeps its own clean context. In Claude Code these are subagents (docs); in the app you can do a simpler version by giving each stage its own chat and pasting between them.

Three prompts to set it up

Run these in order, in one Claude Project, on any plan.

I want to write down what "good" looks like for the thing I produce most often, so that any AI model can be held to it instead of me judging every draft by feel. The work in question is [describe it, for example "weekly client update emails" or "60-second Instagram scripts"].

Interview me first. Ask me about the audience and what they need from it, the structure I use, the tone, the length, the things that are always a mistake in this format, and how I personally can tell a good one from a mediocre one. Ask the questions a few at a time rather than all at once, and push back if my answer is vague, because "professional but friendly" is not a standard, it is a mood.

Then write me a one-page standard I can paste into a Claude Project. It should have a short description of the job, five to eight specific and checkable rules, a list of failure modes to avoid, and a scoring rubric out of ten with what each band means. Make every rule something a model could actually verify in a draft, not an abstract quality.

From now on in this project, never hand me a first draft. Every time I ask you to produce something, run three passes before you show me anything.

Pass one, write the draft. Pass two, switch roles and critique your own draft against the standard in this project as if you were a demanding editor who did not write it, scoring it against the rubric and listing every specific thing that falls short with the line it appears on. Do not be generous, and do not say it is strong overall if it is not. Pass three, rewrite the draft to fix everything the critique found.

Show me only the final version, followed by a short note listing what the critique caught and how you fixed it, so I can see the reasoning without reading three drafts. If after the rewrite the piece still scores below eight on the rubric, tell me that plainly and say what you would need from me to get it over the line.

Package everything we have set up in this project into a reusable Claude skill so I do not have to rebuild it in every new chat.

Write me the SKILL.md. Give it a short lowercase-hyphenated name that does not contain "claude" or "anthropic", a one-line description that says both what it does and exactly when it should trigger, and instructions that carry over my quality standard, the three-pass draft-critique-rewrite loop, and the rubric. The description line matters most, so make it specific about the situation that should activate it rather than describing the output.

Then tell me how to save it as a zipped folder, and give me three real test requests I can run afterwards to check it triggers on its own and that the output actually improves on what I get without it.

The one line worth remembering

Speed is not the story. The story is that as drafting collapses toward free, the value moves entirely to the layer above the model: your judgment, written down, and the loops you have built to enforce it. People who spent 2026 learning prompts for one specific chatbot will be re-learning again next year. People who spent it writing down their standard and building loops around it will just point the same system at whatever is fastest that month.

Sources

Mercury: Ultra-Fast Language Models Based on Diffusion (arXiv)
Inception, Introducing Mercury
Seed Diffusion: A Large-Scale Diffusion Language Model with High-Speed Inference (arXiv)
DiffusionGemma announcement, 10 June 2026
Large Language Diffusion Models, the LLaDA paper (arXiv)
Agent Skills, official overview