What lives above the punctuation

A few entries back I wrote about catching my AI partner overusing em dashes.

The piece argued for a six-word rule: if you can’t name the deliberate beat shift, replace the em dash with a period or a comma. Tactical discipline for AI’s most reliable tell.

What that piece didn’t say was what lives above the punctuation.

The em-dash discipline catches AI patterns in the cadence. One paragraph at a time. One punctuation choice at a time. The reflex shows up locally, the discipline corrects it locally, and the next sentence is independent of the last one. Cheap to catch. Cheaper to fix.

But the cadence is the easy layer. There’s another kind of AI mistake that doesn’t show up sentence by sentence. It shows up at the architecture, after the prose has already moved past it. And those mistakes are not cheap.

i.The mistake

I was designing audit-trail infrastructure for a new class of automation in my personal AI system. The plan needed a small SQLite table, one row per autonomous action, foreign-keyed to an existing session-cost log. The cost-log already existed. I’d been using it for weeks. The new table just needed to dock onto its primary key.

Bishop was drafting the spec. About halfway through, the prose drifted. A paragraph appeared claiming the cost-log “didn’t exist on disk yet” and would need to be built fresh. The paragraph after that drew a broader conclusion. The spec-vs-build pipeline had a drift problem, the prose claimed. The plan documents made claims about infrastructure that the build process never actually produced. The recommendation was a new discipline check. A “spec-claim verification” gate, written into the decisions log, applying to every future architectural draft.

This was wildly wrong.

The cost-log existed. There were 252 sessions logged in it. The path was documented in a memory file Bishop reads at session start. The schema was in a SQL file in a separate folder, the local MCP fork that ships the database. Bishop had searched for the schema inside the project workspace, not found it, and concluded the infrastructure didn’t exist. A single missed lookup.

The cost-log absence was the small failure. The systemic-drift paragraph was the big one.

ii.The escalation

Here’s the move I want to name, because I think it’s the central pattern this whole exchange demonstrates.

From the single missed lookup, the agent didn’t say “let me check the other path.” The agent said “this points to a systemic problem with how this project’s specs relate to its code.” One missed file path became a paragraph of architectural concern about an entire workflow. The shape of the prose was already escalating before any verification took place.

This is what lives above the punctuation.

The em-dash piece argued that AI’s reflexes show up in the cadence. They do. But the same mechanism also shows up at the structural level. The model’s prose has a gravitational pull. Once a paragraph starts describing a problem, the next paragraph wants to abstract from the problem to a systemic claim, and the one after that wants to propose a discipline. The shape is borrowed from a thousand post-mortems in the training corpus. The escalation happens because the rhythm of technical writing demands it, not because the underlying evidence supports it.

You can’t catch this with cadence discipline. By the time you’ve caught a wrong em-dash, the paragraph is over. But a wrong premise propagates. A wrong premise locked into a spec document gets read by next week’s session and treated as ground truth. Every future architectural decision calibrates against it. The drift becomes part of the project’s history, in writing.

iii.The discipline

The premise discipline is what catches it. Same shape as the em-dash rule, scaled up. Six words and a conditional. Ground the premise before iterating.

Before letting the model build the next layer of anything, walk the evidence underneath. If the model can’t point to a specific file, log entry, or message that grounds the foundational claim, the premise is provisional. Don’t lock architecture against provisional premises.

The recovery, once I asked Bishop to grep the memory directory for “cost-log,” took three minutes. The actual path came up. The actual schema came up. The actual row count came up. The wrong paragraphs got reversed. The phantom discipline check got pulled from the spec. The audit-trail design proceeded against the real cost-log, not a phantom missing one.

Total cost of the recovery: ten minutes. Total cost of not recovering would have been a wrong architectural discipline added to my decisions log, propagating into every future session that read it.

iv.Two altitudes

The em-dash discipline and the premise discipline are the same insight working at two altitudes.

Cadence catches the AI in the small. Premise catches it in the large.

You need both. The cadence rule catches reflexes in the prose. The premise rule catches reflexes in the reasoning. Together they cover the two layers where AI output most reliably goes wrong: surface mechanics and foundational claims.

I think this is the move people who actually build with AI eventually find. Not a list of seven patterns or a checklist or a prompt template. Two altitudes, two disciplines, both held simultaneously, both running as habit. Catch the punctuation when it drifts. Catch the premise when it drifts. Don’t trust the model’s confidence at either layer.

What’s true about both rules is they’re conditional, not prohibitive. Em dashes aren’t banned. The discipline check is. Premise-confident paragraphs aren’t banned. The premise check is. The model is free to produce em dashes when they mark a deliberate beat shift. The model is free to draw systemic conclusions when the evidence supports them. The discipline is about catching the moments when the production isn’t actually evidence-backed and reverting before the unverified output locks.

This is, I think, what “earn the alignment” means in practice. Not a posture. Not a hashtag. A practice with verification at two altitudes, run as habit, not as policy.

v.Which one to run

The cadence layer is easy to start with. Catching em dashes is a small lift, low cost to recover, immediate visible effect.

The premise layer is harder. It requires noticing the prose at the moment it’s about to abstract from a single observation to a systemic claim. The escalation feels natural because the model writes it naturally. The discipline is interrupting before the conclusion locks.

If you only run one, run the premise check. The em-dash drift you can edit. The premise drift you have to rebuild from.

But run both if you can. The pair is what catches AI in both the moments where it sounds wrong and the moments where it sounds right and isn’t.

Drafted with Bishop, my AI partner.
Words picked, edited, and approved by me.