Does stricter mean better?

Does stricter mean better? Yes, and by now I can show where the gain sits. Not in a smarter assistant, but in instructions written so that it can follow them without asking me.

This piece is about how those instructions evolved, from loose agreements per conversation to an archive full of decision rules, and what that measurably delivers: less and less typing per finished task.

From explaining to writing down

The way I instruct my assistant has changed shape three times.

Phase one: everything in the conversation. In the beginning I explained per conversation what I wanted, how I wanted it, and what absolutely should not happen. That works, until you notice you're typing the same three corrections every week.

Phase two: instructions in the cloud. Then the agreements moved into project instructions and knowledge pages in my task manager. Write it down once, available in every conversation. All my tasks and protocols lived there, and the assistant read along online.

Phase three: decision rules in files, locally. Now most of the work happens on my own machine, in an archive folder where the assistant opens, edits and runs files itself. The instructions moved along and changed shape. They are no longer descriptions but decision rules: if this, do that, and when in doubt, ask. A main file of nearly eight thousand words points the way, twenty skills each have their own instruction file totalling nearly 37,000 words, and 26 checks watch while the work happens and block anything that breaks a rule.

That move shows up in my own archive. The share of my conversations about work in that local environment jumped in April from one in five to more than half.

What a good rule does

The difference between an instruction that works and one that doesn't sits in what happens when it gets broken.

An example. My weekly news digest put source references at the bottom, each with a link to the video. In a spot check, nine of the 155 links turned out dead. Not a typo: the model writing the summary replaced the video code with a variant it knew from its training. Recognizable enough to pass, invented enough to point nowhere.

I could have written down: "always copy links literally." That's an instruction that works until the model stops paying attention once. What I did instead: the link list is now assembled by code, and a check demands that every video code in the final text comes from that list. If one doesn't match, nothing goes out. That mistake hasn't happened since, and it no longer depends on a model paying attention.

The same happened to more rules: they started as a sentence in an instruction and ended up as a check that blocks work. But not every correction should go that route.

• A forgotten agreement you write down once as a check. This is the clearest case.
• A data entry error, a wrong field or number, you catch with a fixed format and a check in front of it.
• An unclear instruction is partly on you. The rule is that the assistant asks when in doubt; the habit is that you ask more sharply.
• A genuine disagreement is exactly what you don't want to automate away. That's the place where you should be at the controls.

The five hardest rules that grew out of this, with the measurements and stops around them, I described earlier in how I keep my AI in check.

And it measurably delivers

The honest measure isn't how much I type, but how much I type per finished task. Just typing less could also simply mean working less.

In the spring, when the work still happened in chat, it dropped from 466 typed words per finished task in March to 263 in June. A little each month, while the number of finished tasks actually rose.

Then my archive is interrupted, and that deserves an honest footnote. The local environment only keeps work sessions for a limited time, and I realized that too late: the logging from the first weeks after the move is gone. Since then a monthly routine saves the sessions before they expire. That too is a rule born from a mistake.

From mid-July the picture is complete again, and August was the first full month. Those numbers come from the work environment itself, which records per message whether a human typed it:

• 216 work sessions, in which I typed 1,172 messages. That's 5.4 per session, averaging 16 words.
• The assistant wrote 25 words for every word of mine.
• Of everything arriving on my side of the conversation, 9 percent was actually me. The rest was the system feeding itself: results of steps, reports from checks.
• 103 tasks got finished, roughly 179 typed words per task.

The finished tasks come from the same list in both periods, my own task board. What differs is where the typing was recorded: first in the chat archive, then in the local work environment. That's why I don't present the 466, 263 and 179 as one continuous series. But the measure is the same, the direction is the same, and so is the explanation. The assistant needs less and less correcting because the rules already say it, and it runs alone for longer because the checks stop it where things would go wrong. On top of that, the models themselves became more independent over the same period. I can't pull those two effects apart, and for the conclusion I don't need to: stricter up front and better material point the same way.

How I learned to measure this

One more lesson, because it belongs in the honest version. The first version of this article backed its conclusion with a manual sample: I judged per conversation how often I had to steer. When I later wanted to verify that, it turned out I had kept the outcome but not the calculation and the judgements underneath. Redoing it gave a different number, and the difference could just as well be me as the assistant. I no longer use that number; the measurement above therefore comes straight from the environment itself.