Keep Claude Code Up to Date on Time and Date ![rw-book-cover](https://tommcfarlin.com/wp-content/uploads/2026/06/CleanShot-2026-06-26-at-09.35.55-1024x921.png) 🔗 **Source:** [Keep Claude Code Up to Date on Time and Date](https://tommcfarlin.com/keep-claude-code-up-to-date-on-time-and-date/) > [!note]+ Document Notes > tags: [claude-code, developer-tooling, context-engineering, llm-limitations, automation] > author: Tom McFarlin > source: tommcfarlin.com > reference: https://tommcfarlin.com/keep-claude-code-up-to-date-on-time-and-date/ > date created: 2026-06-29 09:00 > > # 🏷️ Title: Keep Claude Code Up to Date on Time and Date > <!-- deep-read:sections start --> ## 🧭 Table of Contents - [📝 Summary](#-summary) - [📖 Main Content](#-main-content) - [🗒️ Notes](#️-notes) - [📚 References](#-references) - [🗣️ Paraphrase](#️-paraphrase) - [📰 Newsletter](#-newsletter) - [✅ Action Items](#-action-items) - [🧪 Hypotheses](#-hypotheses) - [📊 Methodology](#-methodology) - [❓ Questions](#-questions) - [🔮 Future Research](#-future-research) - [💡 Implications](#-implications) - [🧠 Learning Styles Assessment](#-learning-styles-assessment) - [📊 Accessibility Assessment](#-accessibility-assessment) - [🌍 DEIB Assessment](#-deib-assessment) - [✅ Logical Validity](#-logical-validity) - [🛡️ DARVO Analysis](#-darvo-analysis) - [🎯 Conclusion](#-conclusion) ### 🔗 References - [Keep Claude Code Up to Date on Time and Date — Tom McFarlin](https://tommcfarlin.com/keep-claude-code-up-to-date-on-time-and-date/) - [Claude Code hooks reference](https://docs.claude.com/en/docs/claude-code/hooks) - [jq manual](https://jqlang.github.io/jq/manual/) ## 📝 Summary - **What happened.** Tom McFarlin documents a small fix for a real annoyance: Claude Code doesn't track time passing within a long-lived session. He wires a `UserPromptSubmit` hook that runs `date` and injects a fresh, human-readable timestamp into Claude's context on every prompt. - **Why it matters.** Long sessions left open across a workday (or overnight) leave the model reasoning about "today," "this morning," or elapsed build time against a stale snapshot. Anything time-sensitive silently degrades without the user noticing. - **Key stakeholders.** Claude Code power users, DevRel/docs teams who write tooling guidance, and developers building agent workflows where temporal accuracy matters (scheduling, logging, "since yesterday" reasoning). - **Risks and tradeoffs.** Cost is one extra line of context per turn — negligible. No network calls, no new dependencies beyond `date` and `jq`. The main risk is choosing the wrong lifecycle event (the author's first attempt did exactly that). - **Bottom line.** The lesson is bigger than the timestamp: hooks let you close the gap between what Claude Code *assumes* and what's *actually true*, and the right gap is usually not the obvious one. ## 📖 Main Content - **The core problem is "time passing," not "time at startup."** Claude Code captures the date at session launch but has no mechanism to notice that hours have elapsed inside an open session. The author kept sessions open through meetings, lunch, and overnight, so a new prompt the next morning looked identical to one sent a minute later. - **The manual workaround is friction.** Prefixing messages with "it's Thursday at 9am Eastern" works but gets old. A slash command like `/now` would still be the human doing the work; the author wanted the session to know the time without announcing it. - **The fix is a hook.** Claude Code can run a shell command at lifecycle points and feed the output back into the model's context. The `UserPromptSubmit` event fires on every prompt submission, so a hook attached there stamps the current local date/time/timezone before Claude reads the message. - **The instructive failure: `SessionStart` was the wrong door.** It seemed right on paper — fire on spin-up, inject the timestamp, done. But "session start" means launching, resuming, clearing, or compacting; it does *not* fire when a terminal sits open overnight. The timestamp was "frozen in amber." It solved "I just opened Claude" when the real problem was "I never closed Claude." - **Terms.** A *hook* is a user-defined shell command Claude Code runs at a named lifecycle event. `additionalContext` (under `hookSpecificOutput`) is the field whose contents are injected straight into the model's context. `hookEventName` must match the attached event or the output is ignored. `jq` is a command-line JSON processor used here to build the expected JSON shape; `date` formats the timestamp. - **Contested/uncertain claims.** The author says Claude "knows the date, more or less" — the granularity of what Claude natively knows isn't precisely specified, and behavior may vary by client/version. The claim that settings reload without a restart is presented as reliable, with `/hooks` as a fallback to force a reload. ### 🗒️ Notes - The exposing workflow: start a session in the morning, leave it open across meetings/lunch/overnight, for weeks. A new message in the same session carries no signal that time passed. - Desired output, from Claude's side: `Current local date and time: Friday, June 26, 2026 at 9:17 AM EDT (UTC-0400).` - The hook uses `date '+%A, %B %-d, %Y at %-I:%M %p %Z (UTC%z)'` to produce the human-readable stamp, then `jq` wraps it in the JSON shape Claude Code expects. - Key field: `hookSpecificOutput.additionalContext` — its contents get injected into context. `hookEventName` must equal `UserPromptSubmit` or the output is ignored. - No network calls, no dependencies beyond `date` and `jq`, both near-universal on a dev machine (Homebrew installs them otherwise). - Install: merge the hooks block into `~/.claude/settings.json` (global, all projects). If a `hooks` key exists, add `UserPromptSubmit` alongside rather than replacing. - Validation: `jq '.hooks.UserPromptSubmit' ~/.claude/settings.json`. Takes effect on the next prompt with no restart; open `/hooks` once to force a reload if needed. - The takeaway pattern: when something feels like it should already work, a small, boring piece of plumbing is usually missing — and hooks are where you put it. ## 📚 References - [Keep Claude Code Up to Date on Time and Date](https://tommcfarlin.com/keep-claude-code-up-to-date-on-time-and-date/) — the source post (includes the author's gist + README). - [Claude Code hooks documentation](https://docs.claude.com/en/docs/claude-code/hooks) — lifecycle events including `UserPromptSubmit` and `SessionStart`. - [jq manual](https://jqlang.github.io/jq/manual/) — JSON construction with `-n` and `--arg`. - [GNU coreutils `date`](https://www.gnu.org/software/coreutils/manual/html_node/date-invocation.html) — format specifiers used in the stamp. ## 🗣️ Paraphrase - Claude Code captures the date when a session starts but doesn't sense that time keeps moving inside an open session, so it guesses about "this morning," elapsed build time, or whether it's even the same day. Manually prefixing each message with the time fixes it but becomes tedious, and a slash command would still be manual labor. - The durable fix is a `UserPromptSubmit` hook that runs `date`, formats it, and injects a fresh timestamp into context on every prompt. The author's first attempt on `SessionStart` failed because that event doesn't fire when a terminal sits open for hours — same symptom, wrong door. The broader principle: hooks exist to patch the small, boring gaps between what Claude assumes and what's actually true. ## 📰 Newsletter - **Claude Code tip of the week: teach it what day it is.** If you keep a Claude Code session open across your whole workday (guilty), it has no idea time is passing — it reasons about "today" against whenever you launched it. Tom McFarlin's tiny fix wires a `UserPromptSubmit` hook that stamps the real local date, time, and timezone into context on every prompt. No plugin, no restart, just a few lines in `~/.claude/settings.json`. - **Why WordPress and dev folks should care:** any agent workflow that touches scheduling, changelog dates, "since yesterday" reasoning, or how long a build/deploy has been running gets quietly more reliable. It's a clean example of context engineering — feeding the model the world-state it can't observe on its own. - **The meta-lesson worth stealing:** the author's first attempt used the wrong lifecycle event (`SessionStart`) and "solved" a problem he didn't have. Picking the right hook point is the whole game. - Helpful links: the [post](https://tommcfarlin.com/keep-claude-code-up-to-date-on-time-and-date/) and the [Claude Code hooks docs](https://docs.claude.com/en/docs/claude-code/hooks). ## ✅ Action Items #### DevRel - Developer advocacy: package this as a "Claude Code hooks 101" demo — show the `SessionStart` vs `UserPromptSubmit` failure as the teaching beat. - Education: add a short workshop module on lifecycle events and `additionalContext` context injection, with the timestamp hook as the worked example. - Developer experience: ship a copy-paste snippet + README (mirroring the author's gist) in tooling quickstarts; include the `jq` validation one-liner. - Developer marketing: a "stop telling Claude what day it is" content hook is highly shareable; pair with a 60-second clip. - Community management: collect community-contributed hooks into a curated gallery; moderate for safety (shell commands run locally). - Internal/external/cross-project: feed back to the Claude Code docs team that "time doesn't advance in long sessions" is a common, non-obvious gotcha worth a callout. #### OSPO - N/A — no open-source governance, licensing, security-intake, SBOM, or funding dimension in this how-to post. #### Community - N/A — not a project-governance or maintainer/contributor/sponsor topic. #### WordPress - CLI: relevant analogy only — document how environment/context affects CLI agent behavior; otherwise N/A for core WP-CLI. - Documentation: examples-first pattern is directly applicable — show the gap, the wrong fix, then the right fix. Otherwise WordPress-specific subteams are N/A. - Training: a lesson on "context engineering for AI dev tools" could reuse this example; otherwise N/A. - (All other WordPress subteams: N/A — this is editor/agent tooling, not WP core/mobile/playground/themes/plugins work.) #### The WPCC - N/A — no fellowship, microgrant, or funding-experiment angle. ### FAIR - N/A — no metadata-independence, provenance, or anti-capture dimension. ## 🧪 Hypotheses - **H1.** A `UserPromptSubmit` hook injecting current time eliminates time-related guessing in sessions idle for hours, where a `SessionStart` hook does not. - **H2.** The added context cost (one line per turn) is negligible relative to total prompt tokens and has no measurable effect on response quality. - **H3.** Tasks involving "today/yesterday," scheduling, or elapsed time produce more accurate outputs when a fresh timestamp is present versus a stale session-start snapshot. - **H4.** Settings changes to `~/.claude/settings.json` take effect on the next prompt without a restart in the supported client version. - **H5.** Most developers' machines already have `date` and `jq`, so the fix installs with zero new dependencies for the majority. ## 📊 Methodology - **The technical fix (as documented).** Attach a hook to the `UserPromptSubmit` lifecycle event in `~/.claude/settings.json`. On each prompt, a `command`-type hook runs `date` with an explicit format string, and `jq -n` constructs the JSON object Claude Code expects, placing the stamp under `hookSpecificOutput.additionalContext` with `hookEventName` set to `UserPromptSubmit`. The config (the single code block in this note): ```json { "hooks": { "UserPromptSubmit": [ { "hooks": [ { "type": "command", "command": "jq -n --arg ctx \"$(date '+%A, %B %-d, %Y at %-I:%M %p %Z (UTC%z)')\" '{hookSpecificOutput:{hookEventName:\"UserPromptSubmit\",additionalContext:(\"Current local date and time: \" + $ctx + \". This is refreshed on every message; use it as your reference for \\\"now\\\" and \\\"today\\\".\")}}'" } ] } ] } } ``` - **How to test the hypotheses.** (1) A/B compare a session with the hook vs. without, leaving each idle 12 hours, then ask "what day is it / how long since my last message" and score accuracy. (2) Measure token delta per turn to confirm negligible cost (H2). (3) Build a small eval set of time-sensitive prompts (scheduling, elapsed-time, date-arithmetic) and score correctness with/without the hook (H3). (4) Edit settings mid-session and confirm next-prompt effect without restart (H4). (5) Survey/inventory dev machines for `date`/`jq` presence (H5). - **Validation step in the post.** `jq '.hooks.UserPromptSubmit' ~/.claude/settings.json` confirms the merged config is valid JSON and present. ## ❓ Questions - Does `additionalContext` injected every turn accumulate in the visible context window, or is only the latest stamp retained for reasoning? - Are there lifecycle events better suited to *elapsed-time* reasoning (e.g., a delta since last turn) rather than absolute time? - How does behavior differ across Claude Code clients/versions and operating systems (Windows `date` format differences)? - Could the same pattern inject other volatile world-state (git branch, current directory, active PR) usefully without bloating context? - Is there a privacy or leakage concern when timezone/location is always present in context for shared or logged sessions? ## 🔮 Future Research - A taxonomy of "volatile context" worth injecting via hooks (time, VCS state, environment, network status) and the cost/benefit of each. - Empirical study of how stale temporal context degrades agent task accuracy over session age. - Best-practice guidance for choosing lifecycle events — a decision tree mapping symptoms to the correct hook. - Cross-platform portability of `date` format strings and a fallback for non-GNU systems. ## 💡 Implications - **Practice.** Context engineering isn't only about prompts and RAG; lifecycle hooks are a first-class way to keep an agent grounded in present reality. Treat "what the model can't observe" as a checklist. - **Policy.** Teams standardizing on Claude Code may want a shared, reviewed `settings.json` hooks baseline so every developer gets temporal grounding by default. - **Security.** Hook commands run locally with the user's shell — curated galleries and review matter before copy-pasting arbitrary commands. - **Education.** The `SessionStart`→`UserPromptSubmit` story is a reusable teaching artifact about diagnosing the *real* problem versus the apparent one. - **Funding models.** N/A — no funding dimension. ### 🧠 Learning Styles Assessment - Reading level estimate: roughly Flesch-Kincaid Grade 8–10. Conversational, short sentences, light jargon (hook, context, `jq`), accessible to most developers. Flesch Reading Ease estimated ~60–65 (plain, readable). #### 👀 Visual learners - Present: one labeled JSON config block; an example of the rendered timestamp line. - Improve: a before/after diagram (stale snapshot vs. per-turn refresh) and a lifecycle-event timeline showing when each hook fires. #### 🔊 Aural learners - Present: none (text post). - Improve: a 2–3 minute audio walkthrough of the problem, the failed attempt, and the fix. #### 🗣️ Verbal learners - Present: strong analogies ("frozen in amber," "same symptom, different door"), clear term definitions in context. - Improve: a short glossary (hook, lifecycle event, `additionalContext`). #### 🧩 Kinesthetic learners - Present: copy-paste config, a validation command, explicit install steps. - Improve: a checklist and a tiny "verify it worked" experiment (ask Claude the date after idling). #### 🧠 Logical learners - Present: clear cause→effect reasoning, the wrong-event/right-event contrast. - Improve: a decision table mapping lifecycle events to what they (don't) fire on. #### 🧑‍🤝‍🧑 Social learners - Present: gist + README invite reuse. - Improve: a discussion prompt ("what other volatile context do you inject?") and a shared hooks gallery. #### 🧘‍♀️ Solitary learners - Present: self-contained, self-paced how-to. - Improve: a reflection prompt on diagnosing the real problem behind a symptom. #### 🌿 Naturalistic learners - Present: none directly. - Improve: frame "context drift over a session's lifecycle" as an ecosystem/decay analogy. ### 📊 Accessibility Assessment #### Screen reader semantics - Present: assumed headings and a code block on the source page. - Improve: ensure the code block has a programmatic language label and the rendered-timestamp example is real text, not an image. #### Keyboard navigation - Present: standard blog article; no custom interactive widgets. - Improve: ensure any "copy code" button is keyboard-reachable with visible focus. #### Contrast and readability - Present: typical blog typography. - Improve: verify 4.5:1 text contrast and adequate contrast for syntax-highlighted code. #### Text resizing and reflow - Present: prose reflows; risk is the long single-line `command` value overflowing. - Improve: allow the code block to wrap or scroll without clipping at 200% zoom. #### Media and captions - Present: no audio/video to caption. - Improve: if an audio summary is added, provide a transcript. #### Forms and interactions - Present: none beyond a possible copy button. - Improve: label any copy control accessibly ("Copy settings.json hook"). #### Standards reference - Maps to WCAG 2.2 AA: 1.4.3 Contrast (Minimum), 1.4.10 Reflow, 1.4.4 Resize Text, 2.1.1 Keyboard, 2.4.7 Focus Visible, 1.4.13 Content on Hover/Focus (for tooltips/copy affordances). ### 🌍 DEIB Assessment #### Cultural breadth - Present: timezone-aware framing (UTC offset shown), which respects non-single-locale users. - Improve: note Windows/non-GNU `date` differences so non-macOS/Linux readers aren't excluded. #### Inclusive language - Present: plain, neutral, jargon defined in context. - Improve: brief gloss of `jq`/`date` for readers newer to the shell. #### Neurodiversity support - Present: short paragraphs, consistent structure, one clear example. - Improve: a TL;DR box and a numbered install checklist for predictable scanning. #### Representation - Present: single-author first-person account; neutral. - Improve: N/A for representation in a solo technical post. #### Psychological safety - Present: humble, mistake-forward tone ("my first attempt… solved the wrong problem") models safe learning. - Improve: none needed. ### ✅ Logical Validity #### Strong reasoning - **Causal (strong).** The wrong-event diagnosis is well-reasoned: because `SessionStart` doesn't fire on an already-open terminal, its timestamp can't refresh; therefore it can't solve "time passing." Location: the "Why SessionStart Was the Wrong Door" section. - **Deductive (strong).** If `hookEventName` must match the attached event, and the hook is attached to `UserPromptSubmit`, then the field must read `UserPromptSubmit` — stated directly and correctly. - **Inductive (reasonable).** Generalizing from "weeks of leaving sessions open" to the recurring failure mode is a fair inference from repeated personal observation; could be strengthened with others' reports. - Clarify further: quantify token cost and accuracy gain to move H2/H3 from asserted to demonstrated. #### Fallacies - **Hasty generalization (mild).** "both of which are almost certainly already on your machine" assumes a near-universal environment; true for many macOS/Linux devs, less so on bare Windows. Fix: add a one-line cross-platform caveat. - **Anecdotal evidence (mild).** The value claim rests on the author's single workflow; not a real flaw for a how-to, but an eval would harden it. Fix: include a small before/after test. - No manipulative or formal fallacies detected. #### Tone of voice - Conversational, candid, lightly self-deprecating, and pragmatic. Examples: "you'll watch it guess," "frozen in amber," "a rounding error against the value." The mistake-forward framing builds trust. ### 🛡️ DARVO Analysis - N/A. This is a neutral technical how-to with no accusations, conflict, or blame dynamics. There is nothing to deny, no accuser to attack, and no victim/offender role to reverse. The only "blame" is the author owning his own wrong first attempt — the opposite of DARVO. ## 🎯 Conclusion - **Bottom line.** Claude Code doesn't natively notice time passing inside a long-lived session; a `UserPromptSubmit` hook that injects a fresh `date` stamp into context fixes it cheaply and invisibly. The deeper point is that hooks close the gaps between what the model assumes and what's true — and the right gap is often not the obvious one. - **Practical next steps for readers.** Merge the hooks block into `~/.claude/settings.json`, validate with `jq`, send a prompt to confirm the stamp appears, and open `/hooks` if it doesn't reload. Then generalize: audit your agent workflows for other volatile world-state worth injecting, and when picking a hook, make sure the event actually fires when your problem occurs. ## 🔄 Refactor Appendix — Keep Claude Code Up to Date on Time and Date > Density: 2–5 Literature atoms (H3), 0–3 Permanent candidates (H4). > Defaults: 3 Literature, 1 Permanent. Resonance filter: if you can't > articulate in one line why a claim matters, drop it. ### 📚 Literature Atoms (H3) #### [H1] Claude Code freezes time at session start > [!quote] ID:rw_b3_01 > "Leaving for twelve hours and leaving for one minute look identical." **Context & use**: - "The Problem" section — describing the long-lived-session failure. - Names the core gap: the model can't observe elapsed time on its own. **Tags**: #xref **Highlight**: [view highlight](readwise://) <!-- atomicity: 1 idea ✓ --> #### [H2] Native date awareness is unreliable for relative time > [!quote] ID:rw_b3_02 > "It knows the date, more or less. But ask it to reason about “this morning” versus “last night,” ... and you’ll watch it guess." **Context & use**: - Opening paragraph; distinguishes absolute date from relative-time reasoning. - Justifies why a per-turn refresh, not a one-time stamp, is needed. **Tags**: #xref **Highlight**: [view highlight](readwise://) <!-- atomicity: 1 idea ✓ --> #### [H3] UserPromptSubmit fires on every prompt > [!quote] ID:rw_b3_03 > "The right event is UserPromptSubmit . It fires every single time I hit enter." **Context & use**: - "Why SessionStart Was the Wrong Door" — the corrected choice. - The hook point is the whole fix; attach the stamp here, not at start. **Tags**: #xref **Highlight**: [view highlight](readwise://) <!-- atomicity: 1 idea ✓ --> #### [H4] The best fixes remove friction you stop noticing > [!quote] ID:rw_b3_04 > "this isn’t a feature you use; it’s a friction you stop noticing." **Context & use**: - "How It Fits Into a Workflow" — the value framing. - Reframes tooling success as the disappearance of a recurring micro-task. **Tags**: #aphorisms **Highlight**: [view highlight](readwise://) <!-- atomicity: 1 idea ✓ --> #### [H5] Hooks patch the boring gaps between assumption and truth > [!quote] ID:rw_b3_05 > "when something feels like it should already work, there’s usually a small, boring piece of plumbing missing. Hooks are where you put it." **Context & use**: - "The Takeaway" — the generalizable principle beyond timestamps. - Diagnostic heuristic for agent tooling: find the missing plumbing. **Tags**: #aphorisms #articleseed **Highlight**: [view highlight](readwise://) <!-- atomicity: 1 idea ✓ --> ### 🧠 Permanent Candidates (H4) #### [P1] Inject volatile world-state the model can't observe **Claim** (one sentence, Courtney's voice): An agent stays grounded only when each turn carries the volatile world-state it cannot observe on its own, like the current time. **Evidence pointer**: [[#H1]] — and [[#H3]] for the per-turn mechanism. **Scope & conditions**: Holds for long-lived or resumable sessions where context set at start goes stale; breaks when state is cheap to ask for or rarely changes (then injection is just noise). **Links**: - [[Context engineering]] — because extends - [[Prompt-time grounding vs. retrieval]] — because contrasts on when state is supplied - [[Claude Code hooks]] — because applies-in agent-tooling config <!-- atomicity: 1 idea ✓ --> #### [P2] Match the fix to the event that actually fires **Claim** (one sentence, Courtney's voice): A fix works only when it's attached to the lifecycle event that actually fires when the problem occurs, not the one that merely sounds right. **Evidence pointer**: [[#H3]] > [!quote] > "Same symptom, different door." **Scope & conditions**: Holds wherever behavior is hung on lifecycle/event hooks; breaks when a single event covers all relevant triggers. **Links**: - [[Debugging by reproduction conditions]] — because extends - [[Event-driven design]] — because applies-in tooling architecture <!-- atomicity: 1 idea ✓ --> ### ✏️ Fleeting Queue - [F1] Audit my own Claude Code `settings.json` — add the time hook and check for other stale context worth injecting (git branch, cwd). — https://tommcfarlin.com/keep-claude-code-up-to-date-on-time-and-date/ #fleeting #inbox - [F2] Open question: does per-turn `additionalContext` accumulate in the window or only latest stamp matter? — #fleeting #inbox ### → Things 3 (max 2 actions) - [ ] Add the `UserPromptSubmit` time hook to `~/.claude/settings.json` and verify with a post-idle prompt — Claude Code setup #things - [ ] Draft a DevRel snippet/gist mirroring the SessionStart→UserPromptSubmit teaching story — content backlog #things <!-- deep-read:sections end --> 📄 **Full text:** [[Full Document Contents/Articles/Keep Claude Code Up to Date on Time and Date.md|Keep Claude Code Up to Date on Time and Date by tommcfarlin.com]] ## Highlights - It knows the date, more or less. But ask it to reason about “this morning” versus “last night,” or how long a build has been running, or whether it’s even the same day you started, and you’ll watch it guess. So you do what I did for weeks: you open a message with “it’s Thursday at 9am Eastern” just to give it its bearings. ([View Highlight](https://read.readwise.io/read/01kw9qpn7r8qcy5qhnkwmkxq34)) - Note: The problem: Claude Code can't reason about elapsed time / "this morning vs last night" — so users manually prefix the time every message. - Tags: atom/literature/h1, llm-limitations, claude-code - Leaving for twelve hours and leaving for one minute look identical. Nothing in the conversation tells it otherwise, so it carries on as if no time has passed at all. ([View Highlight](https://read.readwise.io/read/01kw9qpqjzgsdzmt7wv7qk9p40)) - Note: The root insight: a model has no sense of elapsed time — "leaving for twelve hours and leaving for one minute look identical." - Tags: atom/literature/h2, llm-limitations - The right event is `UserPromptSubmit`. It fires every single time I hit enter. Stamp the time *there*, and the clock refreshes on every message regardless of how long the session sat idle. The cost is one small line of context per turn, which is a rounding error against the value of Claude actually knowing what day it is. ([View Highlight](https://read.readwise.io/read/01kw9qpt9sz2r8w76pwctz5j4f)) - Note: The fix: hook on UserPromptSubmit (fires every turn) to stamp the time — refreshes the clock regardless of idle gaps. - Tags: atom/literature/h2, claude-code, context-engineering - I spent my first attempt solving “Claude doesn’t know the time at startup” when the real problem was “Claude doesn’t know that time is passing.” Same symptom, different door. The hook didn’t get good until I changed which event I hung it on. ([View Highlight](https://read.readwise.io/read/01kw9qpz4bqkpfftwef6bban5y)) - Note: Debugging lesson: "Same symptom, different door" — the fix only worked once the problem was reframed from startup-state to time-passing. - Tags: claude-code, atom/fleeting/f1 - That’s the pattern worth keeping: when something feels like it should already work, there’s usually a small, boring piece of plumbing missing. Hooks are where you put it. ([View Highlight](https://read.readwise.io/read/01kw9qpwmrhth861qsrra83z5w)) - Note: Zettel: "when something feels like it should already work, there's usually a small, boring piece of plumbing missing. Hooks are where you put it." - Tags: developer-tooling, atom/zettel/z1, context-engineering ## Links - [[Volatile Context Belongs at the Event Where It Changes]] — distilled claim: refresh time on each submitted prompt rather than once at session start. - [[Context Not Constraints Is What Unhobbles an Agent]] — applies-in: the timestamp supplies a fact the model cannot observe instead of another behavioral rule.