2026-01-22 · Glossary

AdHomonym

Ad hominem attacks the person. AdHomonym attacks by name confusion.

Definition

Mistaking two things for the same thing because they share a name or sound similar. A specific type of conceptual error where homonymy (same spelling/sound, different meaning) leads to false equivalence.

The pattern

When our minds encounter the same word used for different things, we unconsciously import properties from one context to another. This is:

• Useful when it's metaphor (intentional connection)
• Confusing when it's accidental (unintended conflation)
• Dangerous in technical contexts (precision matters)

Examples

Everyday: "Bank" (financial institution vs river edge). "Bat" (baseball equipment vs flying mammal). "Match" (fire-starter vs competition vs pair).

Technical: "Service" — microservice, web service, system service, customer service. "Class" — OOP class, CSS class, social class. "Instance" — object instance, EC2 instance, moment in time. "Container" — Docker container, data structure, physical shipping container. "Address" — memory address, street address, formal speech.

Conceptual: "Running" a program vs running a race (execution vs locomotion). "Cloud" storage vs weather clouds. "Character" in a story vs character encoding (persona vs data representation) — the exact split this glossary draws between Character Bible and the Character role above.

Why it matters

Language shapes thought. Shared names create unconscious associations. For humans, context usually resolves ambiguity. For AI systems trained on language patterns, these conflations are amplified — LLMs learn from correlations, making them particularly susceptible to homonym confusion without precise context.

In software

The dangerous ones are where the two meanings seem related but aren't.

• Service. A microservice is not a service like customer service — one is an architecture, one is human interaction. The shared name makes us import properties, and we start expecting a microservice to be "helpful" or "responsive."
• Instance. An EC2 instance is not an instance like an object instance. One is a running VM, one is an object in memory. The collision hides that they're different categories of thing.
• Running. A "running" process isn't running anywhere. The metaphor helped once; now it obscures what's actually happening, which is execution state.

Detection

Ask: "Am I using the same word for two different things?" If explanations feel like they should connect but don't, check for an AdHomonym. It often feels like "but that doesn't make sense because…", "wait, I thought you meant…", or "those are related though, right?"

When defining a term, ask the inverse: is there another meaning of this word that could cause confusion? If yes, pick a different word or say explicitly which meaning you intend. That check is why this glossary draws Character apart from Character Bible instead of letting one word carry both.

Relationship to category error

A category error treats X as type Y when it's fundamentally type Z (treating mind like body). An AdHomonym treats X₁ as X₂ because both are called "X" (treating Python the language like Python the snake). Category error is about logical types; AdHomonym is about naming collision — but they often occur together, since the shared name is what leads to the category confusion in the first place.

The term plays on "ad hominem" (Latin: "to the person"). An AdHomonym is an "attack by homonym" — defeating an argument by confusing which meaning of a word is in play. It was named after noticing how often a technical disagreement turns out to be two people using one word for two things; the silly name is the point, because it has to be callable out loud in the moment.

Related but distinct: semantic ambiguity (the general case of a word having several meanings) and polysemy vs homonymy (related senses vs coincidentally identical spelling).