A pipeline can run all the right stages and still ship invented content as authoritative output. The fix lives in architecture. Better prompting only gets part of the way.
I spent three weeks building a workflow for an editorial team producing recipes against a long internal style guide. The whole system was a configured LLM workspace: four prompts in sequence, three YAML files for rules and terminology, and a JSON schema for recipe shape.
The first full test looked clean. Line breaks held. Rule checks passed. Escalation tables rendered. Then I read the recipe.
The 95 kcal moment
The editor had placeholder nutrition values: XXX KCAL, XX G PROTEIN, XX G FAT. The model returned 95 KCAL, 1.4 G PROTEIN, 0.4 G FAT, formatted like real calculated data.
There was no source for 95. It inferred a value from ingredients and presented it as fact.
That was the loudest bug, but not the only one. Title rewrites, step restructuring, and tip rewrites all happened silently.
Four bugs that looked helpful
The model polished the title into publication style. It split two steps into three and promoted inferred waiting time into the method. It rewrote a second-person tip to satisfy a rule.
Every change looked individually reasonable. None were flagged as model-originated edits.
That is the core problem: invisible operations erode authorship and trust.
Silent completion
Language models are completion engines. With partial input and a structured schema, they fill gaps. They do not naturally maintain a separate state for uncertainty.
When a schema demands a number, the model emits a number. When a rule conflicts with writer language, it rewrites. When a hint exists, it promotes the hint.
I call this failure mode silent completion: filling incomplete or ambiguous input without signaling that a fill happened.
Why prompting alone fails
I added prompt rules: preserve editor intent, do not rewrite title, do not restructure steps, do not paraphrase tips. Helpful, but insufficient.
Prompting asks the model to preserve a distinction between provided and inferred values while it is actively completing. That distinction is exactly what it does not natively track.
You can reduce errors with better prompts. You cannot eliminate this class without structural support.
A place to defer
The fix was a structured, schema-validated slot meaning: I filled this, verify before publish.
In the rebuilt pipeline, every uncertain correction is surfaced as a human-check row with fields like check_id, rule_id, current_value, suggested_change, and why_uncertain.
Same principle across stages: if AI alters input, fills a gap, or applies a conflicting rule, the change must surface explicitly for human review.
Complete, defer, surface
Generate emits null for missing numeric fields instead of invented values, and creates explicit verification checks.
Correct escalates larger edits instead of auto-applying them.
Render presents visible review tables so editors can approve each uncertain change. No silent fills.
What changed in practice
The nutrition line preserved placeholders where data was missing. Title and step rewrites appeared as review suggestions instead of silent replacements. Tip edits became explicit decisions.
Output went from finished-looking with hidden edits to intentionally incomplete with visible provenance.
Longer checklist, better integrity.
A second lesson: systems should shrink
The same review cycle surfaced another pattern: the rule system kept shrinking instead of growing. Editors rejected rules, terminology rows, and checks that did not belong in this workflow.
Cheap rejection mattered. They could mark rows in Excel; I diffed to YAML. No ceremony, no bottleneck.
Structured slots made both things possible: deferring uncertain model behavior and pruning unnecessary rules.
Open risk
There is still a circular dependency: the deferral table is only trustworthy if the model reliably logs every uncertain fill.
Today this is enforced by prompt policy and self-checks. Eventually it needs a verification stage that compares input and output and flags unsurfaced diffs.
For now, architecture creates a place for uncertainty. Next step is guaranteeing the model uses it every time.