Setting up a hook in practice

1. Building: attaching the hook through the agent

Alex had just walked him through it — showing by example how a hook is configured, how the log writes itself, how the computer talks back. That was master work. And now Tommy assembles his hook from scratch and on his own — in his own project, with Sam, from a blank setup to a live log. He has everything he needs in his hands: the HOOK_SPEC spec with three columns, the event → action model, and the understanding that the hook should be attached not by hand in the config, but with words through the agent.

He already has live artifacts from yesterday — Earthquake Radar and the crypto ticker, with games from previous levels lying nearby, the same Tetris. Around them he juggles follow-up tasks by hand, and there is no external trace of what he asked and when. Now he will attach a hook that will keep this log on its own.

Tommy does not even touch the config — he sets the hook with words, just as he is used to:

Set a hook: for each of my requests, append it to requests.log with a timestamp.

“Go on, Sam, just like it says in the spec,” he calls after him. “Event, action, where to write it — it is all there.”

Sam takes that phrase and attaches a real hook. He drops the handler script .claude/hooks/log-prompt.sh and registers the event UserPromptSubmit in .claude/settings.json:

{
  "hooks": {
    "UserPromptSubmit": [
      { "hooks": [ { "type": "command", "command": ".claude/hooks/log-prompt.sh" } ] }
    ]
  }
}

The event is “Tommy submitted a request.” The action is to record the time and the request itself in requests.log. That same arrow, only now not on a scrap of paper but as a live setting. Tommy checks that the hook is in place:

/hooks       # our UserPromptSubmit should be in the list

UserPromptSubmit is visible in the list — the hook is in place, and they can work as usual.

2. The log writes itself

Tommy deliberately takes not made-up commands, but live follow-up tasks — the very ones that had been bugging him in the morning. He asks to tweak the ticker block. He asks to shift the threshold on the radar. And without looking away, he watches the file.

He hits Enter on the first request. A short pause — that very pause when you are still trying to figure out whether something is happening or it is all for nothing. The requests.log file is open beside him, and Tommy keeps glancing at it out of the corner of his eye. And then a line appears on its own in the log: time, his request. He did not type it. He did not open the file, did not append anything, did not move a finger — it just took shape and showed up.

“Whoa,” he blurts out.

He hits the second request — the second line falls in after it, also on its own. The third — the third. He deliberately fires requests more often than necessary, just to watch the file grow without a single movement from him, as if some invisible hand were keeping the protocol for him. Exactly the lines the script writes land there, naturally — time and request text, as is:

[14:32] bring the ticker block back to the previous version
[14:41] raise the magnitude threshold on the radar to 3.0
[14:55] set the ticker background color to dark

And Tommy later adds the notes on what they settled on to the needed lines himself, once the decision is made — the hook does not write those, it only appends the request. That gives two layers: an auto-line from the script plus a manual note about the decision.

[14:32] bring the ticker block back to the previous version
        → decided: format "BTC $XXXXX · updated HH:MM"

Two layers of the log. At the top — the requests.log file: three lines of the form “[time] request” — the hook writes them on its own, for every request; under the 14:32 line — the note “→ decided: format BTC $XXXXX · updated HH:MM”, which Tommy added by hand. Layer 1, auto-line: the hook writes it — on its own, for every request; it holds the time and your request, the hook does not write the agent’s replies; the hook triggers at the moment of sending, so it does not know how it all ended; in the table of contents with bookmarks, these are the lines. Layer 2, note: you write it — by hand, once the decision is made; it holds what you settled on, briefly and in your own words; it sits only at lines where something was decided; these are the bookmarks. You can forget about the first layer — it writes itself. The second is yours: no note — no bookmark Two layers of the log requests.log [14:32] bring the ticker block back to the previous version → decided: format "BTC $XXXXX · updated HH:MM" [14:41] raise the magnitude threshold on the radar to 3.0 [14:55] set the ticker background color to dark hook · auto you · by hand hook · auto hook · auto LAYER 1 · AUTO-LINE LAYER 2 · NOTE Who: the hook — on its own, for every request What: time and your request — not the agent’s replies When: on sending — does not know how it ended Who: you — by hand, once the decision is made What: what you settled on — briefly, in your words Where: only on lines where something was decided “Table of contents with bookmarks” — the lines “Table of contents with bookmarks” — the bookmarks You can forget about the first layer — it writes itself. The second is yours: no note — no bookmark

Tommy opens the log, runs his finger over the lines — and the morning bustle is gone as if it never happened. No more hoping your head will keep the conversation. There it is, the log: what he asked for, when, in what words — it wrote itself; and where needed, his own hand marked what they settled on. Open it — read it. No guessing.

“If I had something like this in the morning,” he says with a smirk, “I would have found that ticker block in ten seconds.”

3. Automation works without reminders

Tommy leans back — and suddenly freezes halfway through the motion. Something does not add up.

“Wait,” he says out loud, to no one in particular. “I actually forgot about this log altogether. Right after Sam plugged it in. I was fixing the ticker, tweaking the radar — and never once remembered it.”

He leans toward the screen again, as if to check whether he imagined it. He opens requests.log. The lines are there, every single one, in a neat column, time after time. He runs his finger from top to bottom and counts his requests from today in his head. It matches. Not a single one was lost.

“So that means…” He hesitates, piecing it together. “I did not keep it myself. I forgot about it. And it is there.”

And then it hits him like a punch to the gut. This morning it was exactly the opposite: forget it — and it is lost; now guess which block it was yesterday, and rage at your leaky head. And now he forgot just the same — and did not lose anything.

“So what,” he says slowly, not quite believing himself, “does that mean you can forget — and nothing gets lost?”

He leans back again, this time all the way, and breaks into a grin.

“This is awesome. My weakest point is that I forget everything — and now it is not even mine anymore. It is right there, in the file. Before, you forgot it — and it was screwed. Now you forget it — and it gets recorded all by itself.”

flowchart TB
  subgraph M["This morning: forget it — and it is lost"]
    direction LR
    M1["Yesterday we settled
on a version"] --> M2["“I will remember”
and did not write it down"] --> M3["Forgot"] -->|"kept in the head —
the head did not hold it"| M4["Lost"] --> M5["In the morning you guess
by feel"]
  end
  subgraph D["Now: forget it — and it is recorded"]
    direction LR
    D1["Sent
a request"] --> D2["The hook recorded it
right away on its own"] --> D3["Forgot"] -->|"kept in the file —
the file does not care"| D4["The line sits
in requests.log"] --> D5["Open it — you see
what you asked and when"]
    D5 -.- D6["“What we settled on” —
only if you noted it yourself"]
  end
  M ~~~ D
  classDef step fill:#F4F6FA,stroke:#B7BFCD,color:#172B53
  classDef forgot fill:#FFFFFF,stroke:#172B53,stroke-width:2px,color:#172B53,font-weight:bold
  classDef lost fill:#FDECEA,stroke:#C62828,stroke-width:2px,color:#C62828,font-weight:bold
  classDef kept fill:#E8F5E9,stroke:#1E8E3E,stroke-width:2px,color:#1E8E3E,font-weight:bold
  classDef hook fill:#E8F5E9,stroke:#1E8E3E,color:#172B53
  classDef manual fill:#FFF4EC,stroke:#C24E06,stroke-dasharray:4 3,color:#C24E06
  class M1,M2,D1,D5 step
  class M3,D3 forgot
  class M4,M5 lost
  class D2 hook
  class D4 kept
  class D6 manual
  style M fill:#FFFFFF,stroke:#C62828,stroke-width:2px,color:#C62828
  style D fill:#FFFFFF,stroke:#1E8E3E,stroke-width:2px,color:#1E8E3E

He grins at his own cleverness: he hardly did anything at all — and the protocol is keeping itself. Pretty slick, he thinks, still not understanding whose slickness it really is.

4. How much each trigger costs

Getting into the groove, Tommy immediately wants more:

“Sam, if it is this easy — let us have a short summary from the logs and the latest edits built automatically with every follow-up.”

Sam attaches that too — on top of the core, like frosting on top, not as a second mandatory win. Tommy is carried away; he would hang a dozen such hooks right now and not even count them.

Alex says calmly:

“Just keep one thing in mind. Every trigger is work, and work burns model resources. Hang fifty hooks — they will keep grinding in the background while the agent runs the task on its own and you are playing games. The reserve is still large, do not worry. But do not ‘throw everything on and not think about it.’”

“The reserve is large, I am not worried.” Tommy snatches exactly that half. He skips over the price — he is a genius of laziness anyway; what limits, the more it does by itself, the better.

Every trigger is work. The day timeline: during the day you work; in the evening you hand the agent a task and go off to play. The “your requests” track: during the day they come one after another; in the evening there are none. The log hook triggers on every request and writes a short line to a file — it does not touch the model, almost free; in the evening it is silent because there are no requests. The summary hook — “frosting on top” — also triggers on every request, but it gathers logs and edits and feeds the model text that it reads every time — each trigger is noticeably heavier than a log line; in the evening it is silent too. A pile of hooks hung on every agent step triggers both during the day and in the evening, while the agent runs the task on its own — without you now, in a solid row. The bottom track is resource usage accumulated over the day: with the log alone the line barely rises; the log with the summary rises on every request and freezes in the evening; with a pile of hooks the line keeps growing in the evening too — the meter ticks even without you. The cost of a hook is how often it triggers multiplied by what it does each time: on every request or on every agent step; a line to a file or text to the model. The reserve is large — but not endless: not “throw everything on and not think,” but hang them and weigh the price Every trigger is work DAY — YOU WORK EVENING — AGENT WORKS, YOU PLAY Your requests Log hook Summary hook Pile of hooks Resource usage per request · line to a file per request · text to model “frosting on top” on every agent step adds up over the day no requests — you are playing silent: no requests — no event silent too agent steps alone — hooks without you pile of hooks — meter ticks without you log + summary — frozen in the evening log only — almost zero script and file — leaves the model alone, almost free feeds text to the model — it reads it every time Hook cost = how often it triggers × what it does each time on every request or on every agent step? · a line to a file or text to the model? The reserve is large — but not endless. Not “throw everything on and not think” — hang them and weigh the price

Oliver, passing by, grumbles his usual line:

“If you give the system free rein, it will pile up work for you without asking, and then you will be the one to clean it up.”

“Uncle Oliver, do you hear yourself?” Tommy is practically glowing. “‘It will pile up work on its own.’ That is a dream! I actually want it to work without asking, so I have less to move around. You just gave me an ad, not a scare tactic.”

5. Set it up once — and it works forever

In the evening, when Tommy is already riding the wave of full autonomy, a line drops into the chat with Tom2036 — and again it is not complete, black blots at the end, as if someone had bitten off its tail:

“‘The best phrase’ — that is exactly right.” Tommy smiles, catching the first, intact half. “It is literally about today.”

And then the line falls apart again — half the words are as if smeared out with a marker. Tommy squints, fishes two surviving words out of the mush: “other people’s money.” What is that about? He has only his own stuff — a laptop and games — no one else’s money in sight. He shrugs — who knows what the channel is throwing together — and reads the rest as a nice extra, an elegant figure of speech in the style of a chat with himself from the future. He smirks and closes the chat. As usual, Tom2036 does not spell anything out.

Tommy is sure down to his heels that the day was a success. He carries away one clean aftertaste: you can set it up — and forget it. The system works on its own in those very places where everything used to rest on him. The image of the morning taxi, with the meter ticking in an empty car, never once comes back to him all day.

He slams the laptop lid shut. Tomorrow he will sort it out, if anything comes up. And this day will be remembered for one thing: for the first time, something is spinning on its own for him while he is busy with something completely different — and that feels warm and ticklish inside, like a small bit of cleverness that actually worked.