Claude workflow upgrade

The Reasoning Floor

For Anthony · June 13, 2026 · making every answer plan and think before it acts

TL;DR

What felt smart about Fable was mostly workflow, not raw model IQ. The fix is to force planning on every problem, not to chase a model.
The right mechanism is a hook: a rule the system runs automatically on every message, so it can never be forgotten. Not a copy-paste, not a soft CLAUDE.md line.
Two layers: the hook always fires (deterministic), and Claude decides how much to apply it (reasoning). Simple asks like "meetings today" stay fast.
Built: a reasoning-floor hook (ready) and a /deep command for deliberate max-depth (live now).
One thing left for you: a single one-time wiring step to switch the always-on hook on. Details at the bottom.

The problem

You noticed that one version of Claude felt sharper at planning, thinking, and figuring out solutions. The instinct was "that model is smarter, how do I get it back." That is the wrong lever to chase.

Honest framing: there is no verified benchmark saying Fable beats Opus 4.8 at reasoning. What you felt was real, but it is almost always a workflow difference, not a raw-intelligence one. When a model plans before it acts, the output feels smart. When it jumps straight to an answer, it feels shallow. That behavior is something you control, on any model.

The deeper problem you actually raised: how do you make that good behavior happen every single time, without having to remember to ask for it. You correctly spotted that a note in a config file is too soft. It gets read most of the time, then quietly skipped on the one messy problem where you needed it most.

What I built to fix it

1 step to activateThe Reasoning Floor (an always-on hook)

A small rule the system runs on its own every time you send a message. It injects one short instruction ahead of your message: judge the difficulty, and if this is a real problem, plan it before answering. It is the automatic floor under every conversation. You never type it and you cannot forget it.

Live nowThe /deep command (deliberate max-depth)

When you already know a problem is big and you want everything Claude has, type /deep followed by the problem. It forces the full treatment no matter how simple the wording looks: question the problem, decompose, generate multiple approaches, stress-test against the strongest counterargument, surface assumptions, then verify. This one is already installed and works in your next session.

The instruction both of these carry was tuned from our conversation. The move you specifically asked to add back is in there:

Restate the problem in one line and confirm it is the real one.
Break it into 3 to 5 smaller sub-problems and solve each. Best quality on each small piece compounds into a better answer on the whole.
Weigh 2 to 3 approaches before committing.
State assumptions and what is unknown.
Answer, then verify against reality before calling it done.

How it works

The key idea is two layers that do not fight each other:

The hook firing is deterministic. It runs 100% of the time, on every message, with zero judgment. This is what kills your original worry. The instruction can never get missed. Delivery is guaranteed.

The simple-vs-hard judgment is reasoning, on purpose. When you ask "what meetings today," Claude reads it, sees a lookup, ignores the heavy steps, and just pulls your calendar. A rigid rule could not tell simple from hard reliably. So the floor always arrives, and Claude decides how much of it to apply.

This is the same split you already use everywhere: the fixed, repeatable work runs as a script (the hook), and the judgment stays with Claude (the gate). Guaranteed delivery plus smart gating, in one setup. Trying to make the judgment deterministic too is the thing that would break it, which is exactly what you suspected.

If Claude ever misjudges (over-thinks a trivial ask or under-thinks a hard one), the correction is one word: shorter or think harder. That is cheaper than tapping yes/no on every message, which is why self-gating beats an approval prompt.

What is required from you going forward

One-time: switch the always-on floor on

The /deep command is already live. The always-on hook needs one small wiring step that I deliberately did not do myself. Your autonomous assistant is walled off from your core Claude config file by design, because a bad edit there could break every Claude session and every automation you run. That wall is a feature. So this last step is yours, and it takes about thirty seconds.

Easiest path: open Claude Code and say:

Add /Users/anthonylim/.claude/hooks/reasoning-floor.sh
as a second UserPromptSubmit hook in my settings.json,
alongside the existing youtube-url-router hook.

Or paste it yourself into the UserPromptSubmit array in ~/.claude/settings.json (next to the YouTube router that is already there):

{
  "hooks": [
    {
      "type": "command",
      "command": "/Users/anthonylim/.claude/hooks/reasoning-floor.sh"
    }
  ]
}

Restart your Claude Code session after, and the floor is live on every message.

Ongoing: almost nothing

Normal work: do nothing. The floor fires on its own. Simple asks stay fast, real problems get planned.
Big problem you want to crush: type /deep then the problem. Full treatment, on demand.
If it ever over- or under-thinks: say shorter or think harder. One word resets it.

Honest expectation: this makes Opus 4.8 perform at its ceiling. It is not a verified clone of Fable. The 20% that felt magic was the planning behavior, and that behavior is what this guarantees on every problem from now on.