Stop Trusting “AI Summaries.” They Are Rewriting Your Care Rules

_How to spot and stop silent policy drift when large language models “help” write health rules.

_Health teams love summaries. They compress long guidance into quick paragraphs. They promise speed. They look harmless. In practice, many “AI summaries” do more than shorten text. They change it. A single modal shift from should to must hardens duties. A widened quantifier turns eligible patients with defined conditions into eligible patients. A passive rewrite removes the actor who is supposed to act. If your agency lets model generated text slip into circulars, billing manuals, or coverage bulletins without a clause level trace, you are not summarizing. You are rewriting care rules without a signature.

This post explains how that happens, how to detect it, and how to build a simple, verifiable guardrail. The goal is practical. Keep the speed, keep the clarity, remove the silent drift.

*The three ways “summaries” mutate policy
*

• Deontic creep. The model upgrades should to must, or replaces may with should. That single word changes the duty of care and the enforcement posture. If it survives into a circular, clinics and payers must comply or face sanction.
• Default scope expansion. The model generalizes. It drops the limiter that protected budget and intent. Eligible patients with defined conditions becomes eligible patients. Service within defined hours becomes service at all times. Costs surge without a formal decision.
• Agent deletion. The model replaces the responsible actor with an impersonal phrase. The provider schedules becomes scheduling is ensured. Accountability vanishes. Audits stall. These are not edge cases. They are common effects of fluent rewriting. Fluency hides change. Screens move quickly. Reviewers are busy. Without structure, the wrong sentence ships.

*Make the clause the unit of control
*
Treat each surviving clause as a decision object. For every clause that makes it into an issued policy, you need three bindings.

Inputs. The prompts, parameters, and sources that proposed the wording, with timestamps and content hashes.

Approvals. The human verdicts that accepted, modified, or rejected the wording, tied to role identities.

Integrity. A small public file that proves the issued text matches a signed bundle, without exposing private notes.

This is not heavy. It is a checklist and a few files. You already have the roles. You already keep records. You need to connect them at the clause level and publish a light integrity signal with the policy.

*The four triggers that must never auto-pass
*

1. Run an automated pass that flags high risk constructions, then require explicit reviewer action. The triggers are simple.
2. Deontic escalation, for example should to must. Require dual countersignature by Legal and Policy. A one sentence rationale that cites the source is enough.
3. Scope change, for example widening a quantifier or dropping a limiter. Require qualifiers or a cross reference to existing limits. If none exists, reject or route to formal approval.
4. Agent deletion. Restore the actor or attach the clause to a responsibility mapping that names a role.

Nominalizations that hide decision rights, for example approval will be sought. Convert to active voice with an actor and deadline, or bind the process to a named role with a time bound.

If a clause triggers any of these, it cannot ship on model authority. A human must own it.

*A realistic before and after
*
Before, model “summary”:
The provider must schedule a telehealth follow up within 48 hours for all patients.

Looks efficient. Reads well. It is wrong on two axes. Duty is hardened for all cases. Scope is widened to all patients.

After, controlled clause:
The provider must schedule a telehealth follow up within 48 hours for high risk patients as defined in Annex A. The provider should schedule a telehealth follow up within 48 hours for other patients, with exceptions documented in the record.

Now the language matches intent. The clause cites a risk definition. The actor is present. The record will show who approved the change and which sources justified it.

*“But we only use AI for drafts”
*
Drafts travel. A sentence accepted “for later refinement” often survives unchanged. Copy paste across documents multiplies the effect. If you cannot show who accepted the sentence and on what basis, you are asking staff and courts to guess. Guessing is not governance.

*Stop thinking “protocol,” start using compiled rule
*
After the first equivalence, treat protocol as regla compilada. The regla compilada is a production procedure. It maps inputs to clauses in a way that is representable, repeatable, and auditable. In practice, that means your drafting pipeline captures:

• Actor and role for every generation and review.
• Model version, provider, and system instructions.
• Parameter ledger, for example temperature and top p.
• Prompt tree with unique identifiers.
• Retrieval sources with content hashes.
• Clause level diffs at each checkpoint.
• Timestamps from a synchronized clock.
• Signatures that bind artifacts to people and time.

You do not need vendor magic. You need discipline and a few simple tools.

*The minimal toolchain that works
*
• Version control for text with a clause mapping script.
• Hashing and signing to bind drafts, inputs, and approvals.
• Manifest files that list prompts, parameters, sources, and verdicts per clause.
• Integrity file published with the policy, so outsiders can verify that the public text matches a signed bundle.

This stack can be built with standard repositories, internal PKI, and lightweight scripts. No proprietary lock in. No model replay required.

*Roles that already exist, duties that become explicit
*
• Policy Lead adopts text, sets scope, signs publication.
• Legal Counsel owns legal sufficiency and records compliance.
• Clinical Safety Reviewer owns duty of care implications.
• Automation Officer owns prompts, parameters, retrieval configuration.
• Records Officer owns keys, time, manifests, retention.

Tie each clause level decision to one or more of these roles. When a trigger fires, demand the right countersignature. You avoid committee drift because the file shows exactly who decided.

*How to add this without slowing down
*
Use snapshots. Four only.

Scoping snapshot. Objectives, affected rules, retrieval whitelist, desired deontic register.

1. - Drafting snapshot. Prompt tree, generated candidates, parameter ledger.
2. - Legal review snapshot. Clause level verdicts and rationales, diffs from previous.
3. - Publication snapshot. Final text bound to the full evidence bundle, public integrity file attached.

Work continues at your current pace. The snapshots make meaning visible. The integrity file makes authenticity visible.

*What your staff will see after one month
*
• Fewer silent escalations from should to must.
• Scope creep caught early and documented.
• Actors restored in clauses, easier audits.
• Shorter disputes, because the file answers who, why, and when.
• Confidence that speed did not erase accountability.

*Frequently heard objections, answered briefly
*
“We do not have time.” You already spend time fixing avoidable disputes. The snapshots and triggers cut that time.

“Vendors handle provenance.” Vendors document systems, not your policy clauses. You need a record that ties specific sentences to your decisions.

“This looks like overkill.” One public incident where an AI summary hardened a duty or widened coverage without approval will cost more than setting the guardrail now.

*A simple starter checklist
*
Today
• Identify one policy type for a pilot.
• Name the five roles.
• Turn on clause mapping and diffs in your repository.

This week
• Add the four triggers to your review.
• Capture model version and parameter logs for every generation.
• Start signing snapshots with synchronized timestamps.

This month
• Publish your first policy with a public integrity file.
• Store the internal bundle under your records schedule.
• Review survival rates for triggered clauses and adjust thresholds.

*The real point
*
Language is infrastructure in healthcare. It allocates duties, money, and risk. If a model proposes language and that language survives into law or policy, a human must own it. Not in a slide. In a file. With a timestamp. With a reason. That is how you keep speed, keep clarity, and keep the authority where it belongs.

**About the author
**Agustin V. Startari, linguistic theorist and researcher in historical studies. Focus on AI language, authority by form, and administrative texts. Researcher ID K-5792-2016.

Ethos

I do not use artificial intelligence to write what I do not know. I use it to challenge what I do. I write to reclaim the voice in an age of automated neutrality. My work is not outsourced. It is authored.

**More work
**Site: https://www.agustinvstartari.com/

SSRN Author Page: https://papers.ssrn.com/sol3/cf_dev/AbsByAuth.cfm?per_id=7639915

Zenodo profile: https://zenodo.org/me/uploads?q=&f=shared_with_me%3Afalse&l=list&p=1&s=10&sort=newest