diffusion models are amazing

the speed claims in this WFD didn't hold up at frontier quality levels. see WFD 38.

i've been spending time with diffusion-based language models and they are genuinely exciting. they're fast in ways that feel wrong if you're used to autoregressive models, because instead of generating one token at a time left-to-right, they generate everything at once and then iteratively refine the noise into coherent text. the whole output materializes in parallel. it's like watching a photo develop in a darkroom instead of watching someone type.

and then you try to actually prompt one and everything you know stops working.

why they're cool

autoregressive models (GPT, Claude, Llama, everything you've used) generate tokens sequentially. each token depends on all the tokens before it. this is why they're slow at long outputs and why streaming exists, you're literally watching the model think one word at a time.

diffusion LLMs skip that entirely. they start with noise across the full output length and denoise it over multiple steps, refining the whole sequence simultaneously. Mercury from Inception Labs demonstrated this hitting sub-200ms time-to-first-token with 1100+ tokens per second on code generation benchmarks. that's not incremental improvement, that's a different category of fast.

the speed comes from the architecture. no sequential dependency means the model can be parallelized in ways autoregressive models fundamentally cannot. you're not waiting for token 47 to finish before token 48 can start. they all start together.

if you haven't tried a diffusion LLM yet, the speed alone is worth experiencing. the first time you send a prompt and the full response appears nearly instantly instead of streaming in, it recalibrates your expectations for what inference can feel like.

why they're surprisingly difficult

here's the part nobody warns you about. every prompting technique you've internalized for autoregressive models either doesn't work or actively hurts you with diffusion models. i found this out the hard way.

negation is dangerous

autoregressive models handle "NEVER do X" reasonably well because they process instructions sequentially. the word "NEVER" modifies the meaning of everything after it in the token stream.

diffusion models don't have that sequential dependency. they see the whole prompt at once and denoise toward the most probable output. "NEVER write raw JSON" teaches the model the pattern write raw JSON just as strongly as it teaches the negation. the bad pattern is right there in the prompt, and the model might denoise toward it because it looks like a high-probability output.

this is the single biggest gotcha. if you're writing system prompts for a diffusion model:

don't say "NEVER write raw JSON"
do say "always respond using the template below" and show the template

show what you want, not what you don't want. the model follows the shape of what it sees.

you must show, not tell

with autoregressive models you can get away with describing the output format in prose. "return a JSON object with fields name, score, and reason" works fine because the model builds the output token by token and the description is enough to guide generation.

diffusion models need the actual shape. they're denoising toward a pattern, and if there's no pattern to latch onto, the output drifts. instead of describing the format, give a filled-in template:

respond exactly like this:

{
  "name": "example name",
  "score": 0.85,
  "reason": "one sentence explanation"
}

the template acts as an attractor in the denoising process. the model sees the structure and refines toward it. without it, you're hoping the model infers the right shape from a description, and that's a coinflip.

enum values go inline, not in a separate list

same principle. if you have a field that should be one of ["low", "medium", "high"], don't list the valid values in a paragraph above the output format. put them directly in the template where the field appears:

{
  "severity": "low | medium | high",
  "description": "what happened"
}

autoregressive models can reference a constraint mentioned 200 tokens ago because they process sequentially. diffusion models denoise the whole output at once, so the constraint needs to be at the point where the value gets generated.

JSON schema enforcement destroys reasoning

this one surprised me. strict JSON schema enforcement (forcing the model to conform to a predefined schema) works great with autoregressive models because you can constrain each token to only valid schema tokens during generation.

with diffusion models, enforcing a rigid output schema during the denoising process reportedly destroys reasoning quality. the schema constraints interfere with the iterative refinement that gives diffusion models their capability. the model can't explore the space of possible outputs because the schema pins down the structure too early.

the fix is softer guidance: show the template, let the model denoise freely, validate after. treat it like editing a draft instead of filling out a form.

temperature matters differently

autoregressive models use temperature to control randomness at each token decision. low temperature means the model picks the most likely next token; high temperature means it samples more broadly.

diffusion models use temperature to control the denoising process globally. too low and the model collapses to the highest-probability output without exploring alternatives. too high and it never converges. the sweet spot is different from what you're used to, and the minimum viable temperature is higher than you'd expect. if you're used to setting temperature: 0 for deterministic outputs, that strategy doesn't translate.

the violation map

i put together a map of every prompting rule i saw being violated when someone tried to use standard autoregressive prompting techniques with a diffusion model. it's not exhaustive but it covers the patterns i kept hitting:

rule	what breaks	why
show the output format as a template	prompts that describe the format in prose without showing it	model has no structural pattern to denoise toward
put constraints inline where values appear	enum values and constraints listed separately from the output format	diffusion models can't reference distant constraints during parallel denoising
use positive instructions only	imperative "NEVER" rules	negation teaches the bad pattern; model denoises toward what it sees
show the template, validate after	strict JSON schema enforcement during generation	schema constraints destroy reasoning quality during iterative refinement
set temperature deliberately	using default or zero temperature	diffusion models need a minimum temperature floor for quality denoising

every single one of these is a case where the technique works fine for autoregressive models and fails for diffusion models because of the fundamental architectural difference: parallel denoising vs. sequential generation.

what this means

diffusion LLMs are not a drop-in replacement for autoregressive models. you can't take your existing prompts, your existing system architectures, your existing schema enforcement pipelines, and point them at a diffusion model and expect the same results. the prompting surface is different because the generation mechanism is different.

but the speed is real, the quality is getting there fast, and the models that combine both approaches (like draft-then-refine pipelines where a diffusion model generates a fast draft and an autoregressive model polishes it) are probably where this all converges.

i'm still early in this. the violation map above came from a few weeks of experimentation and reading, not from running production workloads. but the patterns were consistent enough that i wanted to write them down now rather than wait until i had a cleaner story.

that's what WFDs are for.