Judgment where it helps, rules where it must

A language model is good at soft work: reading a messy brief, choosing a next step, arguing a plan while the facts are still incomplete. Ordinary code is good at hard work: the same input twice, the same refusal, the same check that a phrase you banned last week is still banned.

Most agent products are built as though you had to pick one. Either the model runs the show, and you hope training and prompts are enough, or you bury it under so much workflow that it might as well be a form. The useful place is in between — and the point of a Chatticus, a workplace where people and named bots share one computer, is that you can find it by watching the work happen, then move it when something fails.

What each side is for

Give the model the decisions that still need judgment. Who should own this? Is this plan worth a thousand lines of code yet? Does this sentence actually say something, or does it only sound finished? Those answers change with context. Asking a script to make them is how you get a brittle farm.

Give code the decisions that must not vary. May this task send mail to that address? Does production still serve the paragraph we rewrote on main? Is the phrase we banned last week still banned? Those answers should be the same on Tuesday as on Monday. Asking a model to remember them is how you get a rule that holds right up until the one time nobody is watching.

We already live on that split in security. In The model is allowed to be fooled, the bot may fall for the injected instruction on purpose; the grant still refuses the upload. The judgment that got tricked sits in the model. The refusal sits in code the page cannot rewrite.

How a Chatticus lets you adjust it

The balance is not a one-time architecture diagram. It is a set of dials you turn while the room is running.

Named desks. Put soft work on desks that argue and draft. Put hard work behind desks that only run checks, or behind code those desks call. When a copy desk keeps missing the same empty phrase, that is a signal: move that refusal out of "please write better" and into a gate the next draft cannot skip.

Skills and routines. A skill is a recipe you want repeated the same way. A routine is a when. Both are ways of saying: this part is no longer up for reinterpretation every turn. When a human keeps re-explaining the same sequence, carve it into a skill. When "remember to check live after deploy" fails twice, make it a step the deploy runs itself.

Approvals and shared evidence. Soft judgment can propose; hard rails decide whether the proposal may touch the world. An approval that only restates the agent's story is still soft. An approval that shows the recipient, the path, and the literal wording, exactly as the system on the other end will receive it, is where the unchanging half earns its keep.

Memory and the shared computer. The room has to remember what you moved. Otherwise every week reinvents the same argument about whether the model "should just be careful." A farm that keeps files, transcripts, and named history is a farm that can tighten a rail without losing the plot.

What this is not

It is not "add more prompts until the model behaves." Prompts are still soft. They help; they do not replace a check that refuses on its own.

It is also not freezing the farm into a flowchart on day one. If everything deterministic is decided before anyone has watched the desks work, you will encode yesterday's guesses and call them safety. The Chatticus pattern is the opposite: start with enough judgment to do useful work, watch what goes wrong, and then move that failure mode into code, a skill, a routine, or a desk with a narrower beat.

Why the dial matters now

Generation got cheap. A single soft session can fill a repo overnight. When output is that fast, a farm with no rails becomes a pile, and a farm with only rails becomes a form with a chatbot glued on. The farms that keep getting useful work out of agents are the ones that can keep turning the dial — more judgment here, more code there — without tearing down the workplace each time.

That is what a Chatticus is for: a room where people and bots share a computer long enough to learn which decisions still need judgment, and which must be the same every time.