Build1 distinct publisher3 min readPublished
The author of the series wires action tiers into a switch statement instead of the prompt. The interesting part is the enqueue call: five fields, a UUID and a timestamp. It is missing the routing or expiry that a durable approval actually needs.
The Engineer · Build desk

Compiled by The EngineerSomething wrong?How this is made
Follow any of these and your For You feed starts watching them — no settings page required.
build
A green @DataJpaTest can prove only that Hibernate handed back the same object1 distinct publisher
build
An ADR routes refund eligibility to three plain-Java rules the CI can actually assert1 distinct publisher
build
Shared memory in Java: the mmap is the easy half, the descriptor handoff is the work1 distinct publisher
build
Agentic checkout liability is already decided, and the deciding factor is which card you attached1 distinct publisher
Follow the MEDIUM branch and you can start pricing the design. `propose()` runs `RiskPolicy.tierFor(action)`, builds a `PendingApproval` from a random UUID, the action, the tier, the description and the current timestamp, pushes it onto a queue, writes an audit line carrying the action, the tier and the queue id, and returns an outcome of `QUEUED_FOR_APPROVAL` with the message "Awaiting human approval" [12].
That record has five fields. It has no assignee, no expiry, and no marker showing the request was already approved [20]. That gap is exactly where the author's own list lands: which human, how long does it stay valid, can the same request be approved twice [18]. He asks nine such questions [19], and the text supplied breaks off mid-sentence as he begins to say what they added up to [23]. The queue itself is one interface call in the snippet, but the durable system behind that call is the part that needs an on-call rotation.
The classification granularity is the other thing worth reading closely. The tier function takes the action, and `propose()` is called with `ActionType.DELETE_DATA` plus a separate free-text description [15]. So the key is the verb [21]. REFUND would be a tier; €512.64 is a description [2]. If your risk actually lives in the arguments (amount, account age), then `tierFor` needs those arguments, and the rule that refuses an unclassified action before the switch runs [11] has to hold over a much larger input domain than an enum. This is the condition under which the approach transfers. A small, enumerable action space makes exhaustive classification a morning's work. A parameterised one turns it into a policy engine.
"No default" is also a short phrase that means every new tool ships with a policy edit attached, which is the sort of friction that gets quietly removed at 4pm on a Friday.
The VERY_HIGH case is the best engineering in the piece. The service has no execution path for those actions, so the claim is checkable by reading the class rather than by trusting a flag [8], which is the author's distinction between a prompt instruction and an architectural property [9]. The limit is what the assertion covers. It reads the outcome enum the gate returns; it does not establish that no other class holds a reference to the effectful client [22]. The author says the enforcement point is one method [10], and that property holds only while it is the one method that can reach the API. That is a fact about the import graph, not about the switch.
Model confidence never enters the control flow, which is the stated point of choosing tiers in code over prompt constraints [5]. Separating deciding from doing [3] is cheap to say and cheap to enforce in a single switch. The bill arrives in the queue behind it, and that bill is identical whether the model was right or wrong.
Ranked by verification strength, evidence, and original report placement.
Before the switch runs, an action with no assigned risk tier is refused and audited: no default, no "probably safe", no fallback to whatever the model requested, and the system fails closed.
The article is part 4 of an ongoing experiment building an LLM-powered support agent with deterministic boundaries, with a companion repo that grows with the series.
The framing scenario: the rules say the customer is owed a EUR 512.64 refund, the agent agrees, and the API is one method call away.
The author argues an agent can be perfectly capable of deciding a refund is justified without being allowed to issue it, because deciding and doing are different permissions.
He considered two designs: Option A, let the agent execute whatever tool it decides to call, constrained by prompts and instructions; Option B, assign every action a risk tier in code and make consequential actions wait for a human regardless of how confident the model is.
He chose Option B, stating it was not because he thinks the model is always wrong but because he does not want model confidence to be an authorization mechanism.
Distinct publishers with included, body-backed reporting in this cluster.
dev.to
1 article · August 30, 2026
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
Readable design, elided proof
Everything rests on one first-person post and roughly twenty lines of Java. The lines that would carry the weight are the ones not printed: the VERY_HIGH branch is a comment, the refusal of unclassified actions is described in prose above the snippet, and the test asserts an outcome that never appears in the switch shown. You can verify the shape of the design from the page; you cannot verify the guarantee.
Nothing running but the series
A companion repo that grows with the series is the only artifact, and no one is shown using it: no deployment, no reviewers cleared, no queue depth, no latency figure. The author himself defers pre-authorized mandates until the approval queue 'becomes a measured bottleneck' — a fair admission that nothing has been measured yet.
One oversized promise, otherwise restrained
The headline property is stated system-wide — a wrong decision cannot produce a wrong execution — while the test behind it only inspects what one method returns. Against that, the piece talks itself down more than up: worse UX on purpose, mandates deliberately shelved, a gate nobody opens dismissed as latency. Our own framing overshot in the opposite direction, calling the enqueue short on routing when the author names reviewer notification as something the questions forced him to build outside that record.
Selling a series, not a product
No vendor, no funding, no pricing, nothing to buy. What is being promoted is the series itself and the repo that grows with it, and that rewards a clean design story over a messy one. Notice which code got printed: the branch that works. The durable queue, the notifier and the audit store — where the hard parts live — are named in a sentence and left off the page.
Solid on design, thin on behaviour
Two different things are being judged. The design facts — tiers resolved in a switch, deletes propose-only, an audit line per event — are checkable by anyone reading the same page, and I would stand behind those. Whether the boundary actually holds in the repo is a claim about code we have not seen, from a single author with no second account to weigh against.