The most expensive way to catch a bug is after it ships. The most expensive way to catch a harmful AI output is after a human reads it. Both problems have the same elegant solution: move the evaluation earlier, make it automatic, and encode the rules into the system itself. That's the insight behind Constitutional AI — and it's more mechanical than it sounds. What's Actually Happening A traditional linter like ESLint doesn't understand your code's intent. It holds a list of rules — "no unused variables," "semicolons required," "max line length 80 characters" — and checks each piece of code against them before anything runs. The developer never has to think about those rules consciously during writing; the system surfaces violations automatically. The rules are embedded in the loop. Constitutional AI does the same thing at inference time. The "constitution" is a set of principles — something like "don't provide instructions that could harm someone," "be honest about uncertainty," "respect user autonomy" — and the model is prompted to evaluate its own draft output against these principles before returning a response. If the draft violates a principle, the model revises. This critique-and-revision loop happens within a single inference pass or across chained calls, but crucially, it happens before the output reaches the user. The parallel breaks down in one important place, which is worth understanding: ESLint applies deterministic rules to deterministic code. Constitutional AI applies probabilistic judgment to probabilistic language. The "linter" here is the same model doing the evaluation — which means it can reason about edge cases, nuance, and context in ways no static rule system can. But it also means the evaluation is only as good as the model's understanding of the principles. This is both the power and the fragility. The Scalability Argument Here's why this matters for inference engineering specifically. The naive approach to alignment is human review: have people look at outputs and flag problems. This scales linearly with volume — double the outputs, double the reviewers. It's also inconsistent, slow, and creates a bottleneck that makes real-time applications impossible. Constitutional AI breaks this scaling problem by making the model itself the first-pass reviewer. The compute cost is roughly proportional to the length and complexity of the self-critique, not to the number of human hours available. You can run it on every single output, at every request, simultaneously across millions of users. The "reviewer" is always available, always applies the same principles, and never gets tired. The deeper engineering insight is about where you put the constraint. You can constrain outputs after the fact (filtering), during training (RLHF on human preferences), or at inference time (self-evaluation against a constitution). Each has different cost structures and different failure modes. Post-hoc filtering is cheap but brittle — it catches surface patterns, not intent. Training-time alignment is powerful but slow to update and expensive to retrain. Inference-time constitutional evaluation sits in the middle: it's more flexible than training (you can update the constitution without retraining), more robust than filtering (the model reasons about intent), and more scalable than human review. The Feedback Loop Architecture What makes this genuinely interesting as a systems design pattern is that it creates a self-correcting loop within the inference call itself. The model generates a response, then takes on a different role — the critic — and evaluates that response against the constitution, then takes on a third role — the revisor — and improves it. This is sometimes called a "critic-actor" architecture, and it shows up in agentic systems far beyond safety: code generation where the model tests its own output, writing assistants that check their own arguments for logical consistency, math solvers that verify their own proofs. The constitution is just the clearest example because the principles are explicit and the stakes are obvious. But the pattern is general: any time you can encode evaluative criteria as natural language that the model can reason about, you can embed those criteria into the inference loop and get self-correction for free. The thing about Constitutional AI is that it's not primarily a safety technique — it's a systems architecture for any domain where you want quality control without human bottlenecks. Safety is just the most visible application because the failure modes are most costly there. A model that can check its own work against explicit principles is, in a precise sense, a system that carries its own reviewer inside it. The linter ships with the code.