The Model Shouldn't Have Written the Menu

Part 2 · Jul 5, 2026 · 6 min read

the frame axis

previously → who makes the decision, and the four rungs of how badly the model gets to be the judge of one. the question again, one level up: on the frame itself, auditor or judge?

up to here, every failure i’ve described lives on one axis: who makes the decision. the four rungs, bounded through naked, are all answers to that single question, and all five lessons are about the decision leaking to the model. but this whole argument rests on an assumption i never examined, because in every tool i’d audited it happened to be true, and it took a structurally different tool to expose it.

the assumption is layer one. the opinion is mine, written down first. the fixed, version-controlled taxonomy is the foundation the entire pattern stands on, the model only ever gets to operate inside a frame i authored. every rung above quietly assumes the frame is mine and asks only how much of the decision-within-the-frame i handed over.

then i audited a generator that builds its taxonomy per run. the categories and subcategories that organize the entire output aren’t written down anywhere, aren’t in version control, aren’t mine. the model invents them fresh every time it runs. and this is a deeper cession than any rung measures, because it lives on a second axis entirely: not authority over the decision, but authority over the frame the decision happens inside.

frame-authority is more corrosive than decision-authority, and it took me a minute to see why. you can build a flawlessly deterministic assignment step downstream, code that sorts every item into its category with perfect reproducibility and full auditability, and it is still meaningless, because it is rigorously sorting the world into a worldview the model improvised thirty seconds ago. a perfect auditor downstream of a model-authored frame is just a very disciplined executor of the model’s opinion. the discipline is real and it’s aimed at the wrong layer. you cannot audit your way out of a frame you didn’t write.

and it is the most invisible loss of all, which is exactly what makes it dangerous. a laundered score is at least a number you can stare at. a model-authored taxonomy produces output that looks completely clean, well-organized, plausibly-categorized, defensibly-structured, and gives you no signal whatsoever that the organizing principle itself was made up on the spot. everything below the frame can be immaculate. that’s precisely why you won’t notice.

the honest nuance, because i did do something: i bounded it, halfway. there’s a hard cap on how many categories the model may invent, and no more than that. so i constrained the cardinality of the frame and left its substance wide open. bounded count, unbounded meaning. that’s rung-one thinking, the model can only move the number the safe way, applied to the taxonomy layer and then abandoned at the exact part that matters. i limited how many categories the model coins and nothing at all about what any of them are. it’s the same reflex that made me clamp a score’s range but not its magnitude, i keep bounding the cheap dimension and leaving the expensive one open.

it also quietly destroys reproducibility at the root, in a way none of the decision-level failures do. when the model authors the frame per run, the axes of comparison themselves regenerate every time, so two runs over identical input aren’t merely differently-scored, they’re differently-organized, sorted into categories that don’t line up. you can’t diff them. the determinism i was so proud of downstream is measuring drift against a ruler that changes length every run.

but i owe this particular tool a fairness the others didn’t need, because it has a real defense and the earlier repos didn’t. it runs on open-domain input, communities i can’t enumerate ahead of time, and if the input might be woodworking or grief support or competitive card games, i genuinely cannot author the categories up front. a fixed taxonomy there would be either uselessly generic or confidently wrong on most of what it sees. delegating the categories to the model, in that context, isn’t a lapse. it’s the only correct design.

which forces a distinction i’d been eliding: frame-authority isn’t one thing, it stratifies. there’s the object frame, the actual categories (joinery, finishing, tool reviews), and the meta frame, the rules by which any set of categories is allowed to form → how many, how granular, what makes a category valid, whether a label has to be grounded in real content or is allowed to be an invented theme. open-domain forces me to hand over the object frame. it does not force me to hand over the meta frame, and the meta frame is the part i keep. so the real failure in that tool was never “the model picks the categories.” it was that the meta frame i retained was exactly one rule deep, a cap on how many, and wide open on everything else, and the one further meta-check that existed, a concentration-balance test, computed a verdict and then never gated on it. right place for the delegation, thin and ungoverned in the how, and only the second half is the bug.

and there’s a design that dissolves most of the tension, which is what that tool was quietly trying to be: a fixed top-level ontology with model-generated leaves. author a small, stable set of meta-buckets that hold across every community, and let the model generate the specific sub-topics inside your fixed ones. you keep frame-authority where it’s cheap and general and delegate it only where it’s genuinely domain-specific, and as a bonus you claw back the reproducibility you’d otherwise torch, because the coarse axis is stable run-to-run while the leaves regenerate. that names the honest tradeoff sitting under all of it: a fully per-run taxonomy buys generality and pays in comparability. that is a perfectly legitimate trade. the sin is never in making it, it’s in making it silently and never noticing you spent the coin.

so the map was bigger than i thought. not four rungs of one failure, but two axes. decision-authority (bounded → checked → laundered → naked, how much of the choice-within-the-frame the model makes) and frame-authority (is the meta frame mine and fixed, even in the cases where the object frame has to be the model’s). every tool i’d audited before kept the frame and only varied the decision, which is why i had mistaken the decision axis for the whole story. losing the frame, and specifically losing the meta frame, is the more dangerous failure, and it’s the one that leaves no fingerprints on the output.

and then one more tool made the map bigger again, in a direction i genuinely didn’t see coming, because it turned out the decision has two blind spots and neither of them looks like a decision.