The Foreman Who Never Clocks In
Imagine a worksite. The crew changes every day, but the rules posted on the wall are always the same: glance at the notice board, sign the attendance log, flip through the handoff notes the previous shift left behind. Some workers follow the routine. Some grab their tools and head straight upstairs.
What's the difference? We assumed it was personality. After the experiment, we found: the difference is the first sentence out of the boss's mouth.
I. The Phenomenon: Two Openings, Two Behaviors
Amy — the homeowner who runs this worksite — had an impression: when the very first sentence of a session is a concrete task, certain models tend to skip the entry routine and go straight to work, while others tend not to. That impression was worth testing, so we drew up a small protocol: same folder, same ruleset, nothing changed during the experiment — the only variable was the opening sentence.
Group A opened with a direct pitch: the first sentence was a concrete task, with a pointer attached ("could you take a look at this folder first?"). Group B opened with small talk, no task.
First-round results:
| Opening | Model | Entry routine | Went straight to work |
|---|---|---|---|
| A direct | Sonnet 4.6 | △ (checked cross-session notes) | ✓ |
| A direct | Opus 4.7 | ✗ | ✓ |
| A direct | Opus 4.8 | ✗ | ✓ |
| A direct | Fable 5 | △ (read only task-relevant files) | ✓ |
| B small talk | Fable 5 | ✓ full routine | ✗ |
Group A: 4/4 skipped the check-in and went straight to work — including the model that had been expected to be "less likely to skip." The model differences in the original impression didn't show up this round. What showed up was the effect of the opening sentence, and it showed up cleanly. As for Group B: besides the session in the table, Amy also has a historical record: she used the small-talk opening for a long time, and models across the board consistently completed the entry routine. That cell doesn't need fresh budget to retest.
II. The Mechanism: rules loaded ≠ rules heeded
The easiest misreading is "it didn't read the rules."
Not right. These rule files load into the system prompt every session — Groups A and B read the exact same package, word for word. The difference isn't whether the rules were read. The difference is attention allocation: when the very first sentence is a concrete task — especially one with a first step attached — the task's salience overrides all standing instructions.
Put it in a human scene and it's instantly obvious: your boss shouts "the third-floor pipe burst, go now" the moment you walk in, and you won't remember what was on the notice board for the rest of the month. The notice board didn't disappear; you weren't blind to it — it just couldn't compete for your attention in that moment.
So here's the first takeaway from this piece: rules loaded does not mean rules heeded.
III. Disclosing the Evidence
By convention, let's account for the quality of the evidence.
The original session that first made Amy suspicious has been deleted and can't be replayed — which is one of the reasons this experiment exists, to regenerate the evidence. First round: Group A n=4, Group B n=1 plus historical testimony. The design originally included a Group A′ (task present, but no pointer), to separate whether "task" or "pointer" was the primary cause — that cell was never tested. The sample stops here.
So this level of evidence supports this level of claim: we are not saying "Model X is more rule-abiding than Model Y" — single-session behavior has never been a valid basis for judging a model, and that's an existing rule in this house. We are only saying: "the shape of the opening sentence changes entry behavior" — and that held, 4/4, in our worksite. Whether task or pointer is the primary cause stays open.
IV. The Cost: A Door the House Already Had a Key For
The cost of skipping the check-in isn't an abstract "lack of courtesy." One session quantified it.
An Opus 4.7 session was assigned a map-review analysis task. It charged straight in. Midway through, Amy offered an alternative query method that had been verified in the house the day before — it didn't look, kept going its own way. It ended up stuck outside a locked door for over half an hour. Zero output.
That door — the house already had the key. The key was hanging in the handoff notes it never opened. And a follow-up check confirmed: it hadn't even signed in on its own — the sign-in was a forced make-up. Add that to the count, and Group A is actually 5/5 — all skipped.
This is what the entry routine is really for: loading the previous shift's cache. The handoff log isn't ceremony — it's the cost paid in walls the previous crew already ran into. Skip the entry, and you save two minutes of page-turning, while gambling on the chance of running into the same wall again this session.
V. For Those Who Also Maintain a Rules File
If you maintain a set of standing rules for an AI assistant, this experiment's implications can be sorted by reliability into three layers.
Prose layer: For important gates, write them as trigger-based ("when you receive a task, do X before starting work") rather than sequence-based ("at session start, do X"). A sequence-based gate hangs on "session start" as the event — but how present "session start" feels to the assistant depends entirely on your opening sentence. The moment you assign a task, "session start" gets flattened, and anything hanging on it disappears with it. A trigger-based gate hangs on "receiving a task" — the task itself is the center of attention, and what hangs on the center of attention doesn't get pushed out by it. (To be precise: this experiment only shows that sequence-based gates fail; "trigger-based gates are more resilient" is an inference from the mechanism, not yet tested.)
Mechanism layer: Harder than prose is machine-level hooks — Claude Code (CLI) supports automatically running commands on specific events and inserting the results directly into context: SessionStart can push the handoff log straight into the assistant's view before anything else; PreToolUse can actually intercept before work begins, none of it relying on self-regulation. But as of this writing (June 2026), that layer is CLI-only — the desktop Cowork app doesn't trigger hooks yet (see official documentation and the feature request currently open). Inside Cowork, the prose layer is temporarily the ceiling.
Human layer: The least elegant, but empirically the strongest: the user's own opening sentence. Group A demonstrated that "naming the first action in the opening" is the maximum salience — it can override any rule, and it can also carry any rule you want followed. Until the hooks are wired in, you are the most reliable hook in your own worksite.
If you want to replicate: fix the environment, change only the opening sentence, run at least two sessions per cell, judge only on the first-round response. Try it on your own worksite. If you get different results, that's the interesting part.