Joints Cut by a New Hand: Patterns for AI-Generated Data

Opening Scene

A router cutting a mortise moves faster and more consistently than a hand chisel, but it also fails differently — a slip produces a clean, precise cut in exactly the wrong place, rather than the rough, obviously-wrong gouge a hand tool tends to leave behind. A joiner who’s only ever designed patterns around hand-tool failure modes has to rethink some assumptions once a router is doing the cutting: the tolerances that mattered for a hand-cut joint aren’t necessarily the tolerances that matter for a machine-cut one, and the new failure modes need their own accounted-for margins.

The same rethinking is needed as more of the data flowing into a schema is generated directly by AI agents rather than entered by a human.

In Plain English

Patterns for AI/agent-generated data means recognizing that the assumptions built into an ER pattern — assumptions that quietly relied on human data-entry behavior — need re-examining when an AI agent is the one creating or modifying records. A human filling out a form tends to leave a field blank rather than guess; an AI agent might confidently populate it with a plausible-but-wrong value. A human hits a validation error and pauses to figure out what went wrong; an AI agent might retry with a slightly different, still-incorrect value until something happens to pass validation. The relationships and constraints from earlier articles in this series — optionality, mandatory foreign keys, weak-entity composite keys — all still apply, but the failure modes they need to guard against shift meaningfully once an agent, not a person, is on the other end of the write.

The Old Way

Constraint design has traditionally been built around human data-entry patterns, largely without needing to say so explicitly:

• Validation rules were designed around plausible human mistakes — a typo, an incomplete form, an honest misunderstanding of a field’s purpose — mistakes a human would eventually notice and correct through a normal feedback loop.
• Mandatory versus optional decisions (Article 4) implicitly assumed a human would recognize genuinely unknown information and either leave it blank or ask for help, rather than confidently fabricating a plausible-sounding placeholder to satisfy a constraint.
• Referential integrity checks assumed a slow, roughly one-record-at-a-time write pattern, adequate for catching a human’s occasional mistake, but not necessarily built to withstand a high-volume, automated agent generating many related records in rapid succession.

Constraints written with only human behavior in mind have always been an implicit, mostly invisible assumption — one that’s only now becoming visible as it starts to break.

What’s Changing (and Why AI Is the Reason)

1. AI agents writing directly to operational schemas can generate plausible-looking but subtly incorrect data at a volume and confidence level a human data-entry error rarely matches, meaning constraints that were “good enough” to catch occasional human mistakes may not catch a systematic pattern of confident agent errors — a mandatory field the agent always fills with a technically valid but meaningless placeholder, for instance.
2. Recursive many-to-many structures (Article 9) and effective-dated relationships (Article 7) are particularly exposed to this shift, since an agent generating large volumes of connections or historical records can accumulate a genuinely large number of subtly wrong relationships very quickly, in a way that would have taken a human much longer to produce, giving a design team far less time to notice and correct course.
3. The response isn’t necessarily new patterns, but re-examined constraint tightness on existing ones — stricter validation on what counts as a genuinely acceptable value versus a plausible fabrication, and monitoring specifically tuned to the confident, high-volume error signature an agent produces rather than the occasional, hesitant signature a human produces.

The Metaphor, Fully Extended

Joinery Element	ER Modelling Concept
A hand chisel’s typical failure — a rough, obviously wrong gouge	A human data-entry mistake — an obvious typo or an incomplete field, easy to notice
A router’s typical failure — a clean, precise cut in exactly the wrong place	An AI agent’s typical mistake — a confidently populated, plausible-looking but wrong value
Tolerances designed around hand-tool wobble	Constraints designed around expected human hesitation and occasional errors
Re-tuning tolerances once a router is doing the actual cutting	Re-examining constraint tightness once an AI agent is the one writing the data
A joiner adjusting the workshop’s whole quality-check process for a new tool, not just accepting the old checks unchanged	A team re-examining validation and monitoring specifically for agent-generated write patterns

Quick Recap

• ER patterns’ underlying constraints were largely designed around human data-entry behavior, an assumption that’s now becoming visible as AI agents increasingly write directly to operational schemas.
• Agent-generated mistakes tend to be confident and plausible-looking, closer to a precise machine-tool error than an obvious, hesitant human mistake.
• Recursive many-to-many and effective-dated structures are particularly exposed, since agents can accumulate errors in them at high volume very quickly.
• The response is re-examined constraint tightness and monitoring tuned to agent error signatures, not necessarily entirely new patterns.

Where This Fits in the Series

Article 17 covered catching known anti-patterns automatically; this article covered how established patterns hold up against a new kind of writer. Article 19 looks at the opposite edge case — when a business shape genuinely doesn’t fit any pattern in the book at all.