diff --git a/README.md b/README.md index 767429a..f006fa3 100644 --- a/README.md +++ b/README.md @@ -7,3 +7,4 @@ Some notes on engineering. 1. [Dude, where's my team?](./entries/001-dude-wheres-my-team/) — _Mar 23, 2026 · ~7 min_ 2. [IC Dead People](./entries/002-ic-dead-people/) — _Apr 6, 2026 · ~3 min_ 3. [LOC(o)](./entries/003-loco/) — _Apr 17, 2026 · ~5 min_ +4. [Don't conversate, navigate](./entries/004-dont-conversate-navigate/) — _Apr 25, 2026 · ~6 min_ diff --git a/entries/004-dont-conversate-navigate/.audio-hash b/entries/004-dont-conversate-navigate/.audio-hash new file mode 100644 index 0000000..85c0386 --- /dev/null +++ b/entries/004-dont-conversate-navigate/.audio-hash @@ -0,0 +1 @@ +f9086a1888fd7001176b29b4ad70d4820211d8694cffe1facd11b47713ae0dcd diff --git a/entries/004-dont-conversate-navigate/.speech-hash b/entries/004-dont-conversate-navigate/.speech-hash new file mode 100644 index 0000000..322f8c3 --- /dev/null +++ b/entries/004-dont-conversate-navigate/.speech-hash @@ -0,0 +1 @@ +f49e9f8362d0785c11259c7b8a785ccf23910e75669ff8268a5e32e3e7ad22c5 diff --git a/entries/004-dont-conversate-navigate/body.md b/entries/004-dont-conversate-navigate/body.md new file mode 100644 index 0000000..0aab9aa --- /dev/null +++ b/entries/004-dont-conversate-navigate/body.md @@ -0,0 +1,34 @@ +The agent says something off. You correct it. It tries again. You correct it again. Three turns later you're negotiating with a version of yourself from an hour ago, and the apparent way out is to keep talking. + +Conversation analysts named this a long time ago. Schegloff, Jefferson and Sacks called it the [preference for self-correction in repair](https://www.conversationanalysis.org/schegloff-media-archive/preference-for-self-correction-in-repair-in-conversation-1977/), and later sharpened next-turn repair as the [last structurally provided defense of intersubjectivity](https://www.conversationanalysis.org/schegloff-media-archive/repair-after-next-turn-1992/). The medium of talk only gives you forward-directed tools for fixing issues. You don't un-say the last turn. You say the next one, hopefully better. + +LLM chat inherited the entire stance. + +The lineage is continuous and turn-based at every step. [ELIZA](https://dl.acm.org/doi/10.1145/365153.365168), Weizenbaum's 1966 keyword-matching therapist simulator, decomposes a sentence by rule and reassembles a response, one exchange at a time. [PARRY](https://en.wikipedia.org/wiki/PARRY), Colby's 1972 simulation of paranoid affect at Stanford, adds internal state and keeps the loop. [SmarterChild](https://en.wikipedia.org/wiki/SmarterChild), the early-2000s ActiveBuddy bot living inside AIM and MSN, embedded the turn-bubble grammar in ambient IM where users already knew the moves. By the time [GPT-3](https://arxiv.org/abs/2005.14165) shipped in 2020, "chat with bubbles" wasn't a design decision. It was a default nobody had to make. + +Worth noticing that GPT-3's first surface wasn't chat. The [Playground](https://openai.com/index/openai-api/), OpenAI's web interface for the API, was a text completion box. You wrote text, the model continued it. The conversational shape came later and on purpose. [InstructGPT](https://cdn.openai.com/papers/Training_language_models_to_follow_instructions_with_human_feedback.pdf), OpenAI's 2022 RLHF-tuned successor to GPT-3, trained the assistant role into the weights and taught the model to follow instructions in dialogue. ChatGPT productized it. The [Chat Completions API](https://platform.openai.com/docs/api-reference/chat/create) baked the turn structure into the wire format itself as a `messages` array of `{role, content}` pairs, indexed by position, with no slot for a branch. + +Three layers converged on the same shape, and each one keeps pushing in the same direction: The UX renders the conversation as a linear scroll. Training optimizes for a helpful next turn, never for revisiting a prior one. The wire format is a flat, ordered array going in one direction - forward. + +--- + +Backtracking is, of course, not a new ask. Undo, history, branching. Interactive computing has been working the problem of stepping back for half a century, and harnesses sit squarely inside that lineage. + +Engelbart introduced undo in the [1968 NLS demo](https://www.dougengelbart.org/theDemo) as a recovery move on a linear edit stream, the simple "if I make some mistakes, I can back up a little bit." Emacs [undo-tree](https://www.dr-qubit.org/undo-tree.html) exposed the branching, drew the tree, and let you browse it. Git treated every commit as a node and every branch as a peer of every other. The capability has been there forever. What varies is the **affordances** the software builds around it: how visible prior states are, how cheap the move back is to invoke, and the fate of any path you leave behind. And on exactly these aspects, harnesses sit on the fence. The conversational framing they inherit pushes hard against the tradition, and the affordances a harness ships can either lean into it or work against it. + +[Pi](https://github.com/badlogic/pi-mono), an open-source coding harness, takes the navigable line: `/tree` exposes the session as a tree you can step through, hop between siblings, summarize the abandoned branch forward instead of losing it. Claude Code and Codex CLI, both vendor products, ship the same underlying capability — Claude Code's [`/rewind`](https://code.claude.com/docs/en/checkpointing), Codex CLI's [Esc+Esc](https://developers.openai.com/codex/cli/features) — but route it through indirection: rewind is _destructive_ to the active conversation, and any sibling branch requires forking off into a separate session. Going back exists, but framed as recovery rather than navigation. I'd argue the indirection on the vendor side isn't innocent. It's a position with revenue attached. Forward-correction burns tokens, every retry billed at full rate. Sessions belong to the platform, resumption funnels through it, and the framing keeps tooling sticky and harder to leave. The engineering is small. The reluctance isn't accidental. + +Set the vendor question aside, though, and the open-source story isn't the ceiling either. Pi's `/tree` is a starting point, not a destination, and the affordances around it have plenty of room to grow. The most basic is naming turns, so the user can point at where they want to go back to instead of guessing or going one-by-one. A reactive one would be a glanceable indicator of session depth and shape, so the user can see how far down a branch they are without invoking anything. A proactive one could detect lightweight patterns on the user's recent turns, surfacing a quiet "you might want to rewind" nudge when they're forward-correcting in circles. These are three of probably many. Pi can already support that kind of grafting through its extension system, but whether a harness is open enough to invite it is itself a stance, and the choice dictates how much the user is allowed to take into their own hands. + +--- + +Speaking of taking things into our own hands. Dex Horthy, founder of HumanLayer, on what makes agents work, lands on a principle that transfers cleanly: [you cannot outsource the thinking](https://home.mlops.community/public/videos/12-factor-agents-patterns-of-reliable-llm-applications-dexter-horthy-agents-in-production-2025-2025-08-06). The agent amplifies the quality of thinking already done. The human stays in the driver's seat for architectural decisions. Tool choice matters, but so does the posture brought to the session. + +Treating the transcript as addressable state is part of that posture. Pruning, branching, stepping back, summarizing the abandoned branch forward. It's not a power-user feature waiting on a vendor to ship it. It's a **stance** the user takes about whose conversation this is, and whose thinking it carries. + +And the stakes here are higher than in the editor-focused days. A user in an IDE didn't need a reminder that the past exists, the file wasn't pretending to be a conversation. A chat-shaped session is, and every cue inside it tells you to type the next thing. The LLM's non-determinism sharpens it: forward-correction is the move with no rerun. Typing harder won't reroll the trajectory; only rewinding to a cleaner state and rolling again will. And the cost stacks. Failed attempts stay in context as distractors, biasing what comes next and inflating attention cost. [Lost-in-the-middle](https://arxiv.org/abs/2307.03172) and [context rot](https://www.trychroma.com/research/context-rot) are well-documented at this point. Every forward-correction degrades what follows, and the spiral of half-fixes feels like progress until you find yourself asking, with Neo, how deep the rabbit hole goes. The way out isn't another turn. It's a _step back_. + +What's missing isn't the technology. If [Attention is all the model needs](https://arxiv.org/abs/1706.03762), then attention to where you've been in the session, and to the affordances you're given to get there, is what we owe ourselves. + +xoxo, +ESCESC. diff --git a/entries/004-dont-conversate-navigate/dont-conversate-navigate.mp3 b/entries/004-dont-conversate-navigate/dont-conversate-navigate.mp3 new file mode 100644 index 0000000..a1f2bd9 Binary files /dev/null and b/entries/004-dont-conversate-navigate/dont-conversate-navigate.mp3 differ diff --git a/entries/004-dont-conversate-navigate/index.md b/entries/004-dont-conversate-navigate/index.md new file mode 100644 index 0000000..fb73048 --- /dev/null +++ b/entries/004-dont-conversate-navigate/index.md @@ -0,0 +1,52 @@ +--- +title: "Don't conversate, navigate" +layout: post +reading_time: "~6 min" +author: "Dean Harel" +date: 2026-04-25 +--- + +**Date:** Apr 25, 2026 · **Reading time:** ~6 min + +**Audio version:** + + +--- + +The agent says something off. You correct it. It tries again. You correct it again. Three turns later you're negotiating with a version of yourself from an hour ago, and the apparent way out is to keep talking. + +Conversation analysts named this a long time ago. Schegloff, Jefferson and Sacks called it the [preference for self-correction in repair](https://www.conversationanalysis.org/schegloff-media-archive/preference-for-self-correction-in-repair-in-conversation-1977/), and later sharpened next-turn repair as the [last structurally provided defense of intersubjectivity](https://www.conversationanalysis.org/schegloff-media-archive/repair-after-next-turn-1992/). The medium of talk only gives you forward-directed tools for fixing issues. You don't un-say the last turn. You say the next one, hopefully better. + +LLM chat inherited the entire stance. + +The lineage is continuous and turn-based at every step. [ELIZA](https://dl.acm.org/doi/10.1145/365153.365168), Weizenbaum's 1966 keyword-matching therapist simulator, decomposes a sentence by rule and reassembles a response, one exchange at a time. [PARRY](https://en.wikipedia.org/wiki/PARRY), Colby's 1972 simulation of paranoid affect at Stanford, adds internal state and keeps the loop. [SmarterChild](https://en.wikipedia.org/wiki/SmarterChild), the early-2000s ActiveBuddy bot living inside AIM and MSN, embedded the turn-bubble grammar in ambient IM where users already knew the moves. By the time [GPT-3](https://arxiv.org/abs/2005.14165) shipped in 2020, "chat with bubbles" wasn't a design decision. It was a default nobody had to make. + +Worth noticing that GPT-3's first surface wasn't chat. The [Playground](https://openai.com/index/openai-api/), OpenAI's web interface for the API, was a text completion box. You wrote text, the model continued it. The conversational shape came later and on purpose. [InstructGPT](https://cdn.openai.com/papers/Training_language_models_to_follow_instructions_with_human_feedback.pdf), OpenAI's 2022 RLHF-tuned successor to GPT-3, trained the assistant role into the weights and taught the model to follow instructions in dialogue. ChatGPT productized it. The [Chat Completions API](https://platform.openai.com/docs/api-reference/chat/create) baked the turn structure into the wire format itself as a `messages` array of `{role, content}` pairs, indexed by position, with no slot for a branch. + +Three layers converged on the same shape, and each one keeps pushing in the same direction: The UX renders the conversation as a linear scroll. Training optimizes for a helpful next turn, never for revisiting a prior one. The wire format is a flat, ordered array going in one direction - forward. + +--- + +Backtracking is, of course, not a new ask. Undo, history, branching. Interactive computing has been working the problem of stepping back for half a century, and harnesses sit squarely inside that lineage. + +Engelbart introduced undo in the [1968 NLS demo](https://www.dougengelbart.org/theDemo) as a recovery move on a linear edit stream, the simple "if I make some mistakes, I can back up a little bit." Emacs [undo-tree](https://www.dr-qubit.org/undo-tree.html) exposed the branching, drew the tree, and let you browse it. Git treated every commit as a node and every branch as a peer of every other. The capability has been there forever. What varies is the **affordances** the software builds around it: how visible prior states are, how cheap the move back is to invoke, and the fate of any path you leave behind. And on exactly these aspects, harnesses sit on the fence. The conversational framing they inherit pushes hard against the tradition, and the affordances a harness ships can either lean into it or work against it. + +[Pi](https://github.com/badlogic/pi-mono), an open-source coding harness, takes the navigable line: `/tree` exposes the session as a tree you can step through, hop between siblings, summarize the abandoned branch forward instead of losing it. Claude Code and Codex CLI, both vendor products, ship the same underlying capability — Claude Code's [`/rewind`](https://code.claude.com/docs/en/checkpointing), Codex CLI's [Esc+Esc](https://developers.openai.com/codex/cli/features) — but route it through indirection: rewind is _destructive_ to the active conversation, and any sibling branch requires forking off into a separate session. Going back exists, but framed as recovery rather than navigation. I'd argue the indirection on the vendor side isn't innocent. It's a position with revenue attached. Forward-correction burns tokens, every retry billed at full rate. Sessions belong to the platform, resumption funnels through it, and the framing keeps tooling sticky and harder to leave. The engineering is small. The reluctance isn't accidental. + +Set the vendor question aside, though, and the open-source story isn't the ceiling either. Pi's `/tree` is a starting point, not a destination, and the affordances around it have plenty of room to grow. The most basic is naming turns, so the user can point at where they want to go back to instead of guessing or going one-by-one. A reactive one would be a glanceable indicator of session depth and shape, so the user can see how far down a branch they are without invoking anything. A proactive one could detect lightweight patterns on the user's recent turns, surfacing a quiet "you might want to rewind" nudge when they're forward-correcting in circles. These are three of probably many. Pi can already support that kind of grafting through its extension system, but whether a harness is open enough to invite it is itself a stance, and the choice dictates how much the user is allowed to take into their own hands. + +--- + +Speaking of taking things into our own hands. Dex Horthy, founder of HumanLayer, on what makes agents work, lands on a principle that transfers cleanly: [you cannot outsource the thinking](https://home.mlops.community/public/videos/12-factor-agents-patterns-of-reliable-llm-applications-dexter-horthy-agents-in-production-2025-2025-08-06). The agent amplifies the quality of thinking already done. The human stays in the driver's seat for architectural decisions. Tool choice matters, but so does the posture brought to the session. + +Treating the transcript as addressable state is part of that posture. Pruning, branching, stepping back, summarizing the abandoned branch forward. It's not a power-user feature waiting on a vendor to ship it. It's a **stance** the user takes about whose conversation this is, and whose thinking it carries. + +And the stakes here are higher than in the editor-focused days. A user in an IDE didn't need a reminder that the past exists, the file wasn't pretending to be a conversation. A chat-shaped session is, and every cue inside it tells you to type the next thing. The LLM's non-determinism sharpens it: forward-correction is the move with no rerun. Typing harder won't reroll the trajectory; only rewinding to a cleaner state and rolling again will. And the cost stacks. Failed attempts stay in context as distractors, biasing what comes next and inflating attention cost. [Lost-in-the-middle](https://arxiv.org/abs/2307.03172) and [context rot](https://www.trychroma.com/research/context-rot) are well-documented at this point. Every forward-correction degrades what follows, and the spiral of half-fixes feels like progress until you find yourself asking, with Neo, how deep the rabbit hole goes. The way out isn't another turn. It's a _step back_. + +What's missing isn't the technology. If [Attention is all the model needs](https://arxiv.org/abs/1706.03762), then attention to where you've been in the session, and to the affordances you're given to get there, is what we owe ourselves. + +xoxo, +ESCESC. diff --git a/entries/004-dont-conversate-navigate/speech.md b/entries/004-dont-conversate-navigate/speech.md new file mode 100644 index 0000000..8fe086e --- /dev/null +++ b/entries/004-dont-conversate-navigate/speech.md @@ -0,0 +1,36 @@ +The agent says something off. You correct it. It tries again. You correct it again. Three turns later you're negotiating with a version of yourself from an hour ago, and the apparent way out is to keep talking. + +Conversation analysts named this a long time ago. Schegloff, Jefferson and Sacks called it the preference for self-correction in repair, and later sharpened next-turn repair as the last structurally provided defense of intersubjectivity. The medium of talk only gives you forward-directed tools for fixing issues. You don't un-say the last turn. You say the next one, hopefully better. + +LLM chat inherited the entire stance. + +The lineage is continuous and turn-based at every step. ELIZA, Weizenbaum's 1966 keyword-matching therapist simulator, decomposes a sentence by rule and reassembles a response, one exchange at a time. PARRY, Colby's 1972 simulation of paranoid affect at Stanford, adds internal state and keeps the loop. SmarterChild, the early-2000s ActiveBuddy bot living inside AIM and MSN, embedded the turn-bubble grammar in ambient IM where users already knew the moves. By the time GPT-3 shipped in 2020, "chat with bubbles" wasn't a design decision. It was a default nobody had to make. + +Worth noticing that GPT-3's first surface wasn't chat. The Playground, OpenAI's web interface for the API, was a text completion box. You wrote text, the model continued it. The conversational shape came later and on purpose. InstructGPT, OpenAI's 2022 reinforcement-learning-from-human-feedback-tuned successor to GPT-3, trained the assistant role into the weights and taught the model to follow instructions in dialogue. ChatGPT productized it. The Chat Completions API baked the turn structure into the wire format itself as a messages array of role/content pairs, indexed by position, with no slot for a branch. + +Three layers converged on the same shape, and each one keeps pushing in the same direction: The UX renders the conversation as a linear scroll. Training optimizes for a helpful next turn, never for revisiting a prior one. The wire format is a flat, ordered array going in one direction - forward. + +--- + +Backtracking is, of course, not a new ask. Undo, history, branching. Interactive computing has been working the problem of stepping back for half a century, and harnesses sit squarely inside that lineage. + +Engelbart introduced undo in the 1968 NLS demo as a recovery move on a linear edit stream, the simple "if I make some mistakes, I can back up a little bit." Emacs undo-tree exposed the branching, drew the tree, and let you browse it. Git treated every commit as a node and every branch as a peer of every other. The capability has been there forever. What varies is the affordances the software builds around it: how visible prior states are, how cheap the move back is to invoke, and the fate of any path you leave behind. And on exactly these aspects, harnesses sit on the fence. The conversational framing they inherit pushes hard against the tradition, and the affordances a harness ships can either lean into it or work against it. + +Pi, an open-source coding harness, takes the navigable line: the slash tree command exposes the session as a tree you can step through, hop between siblings, summarize the abandoned branch forward instead of losing it. Claude Code and Codex CLI, both vendor products, ship the same underlying capability — Claude Code's slash rewind command, Codex CLI's double escape key combination — but route it through indirection: rewind is destructive to the active conversation, and any sibling branch requires forking off into a separate session. Going back exists, but framed as recovery rather than navigation. I'd argue the indirection on the vendor side isn't innocent. It's a position with revenue attached. Forward-correction burns tokens, every retry billed at full rate. Sessions belong to the platform, resumption funnels through it, and the framing keeps tooling sticky and harder to leave. The engineering is small. The reluctance isn't accidental. + + + +Set the vendor question aside, though, and the open-source story isn't the ceiling either. Pie's slash tree command is a starting point, not a destination, and the affordances around it have plenty of room to grow. The most basic is naming turns, so the user can point at where they want to go back to instead of guessing or going one-by-one. A reactive one would be a glanceable indicator of session depth and shape, so the user can see how far down a branch they are without invoking anything. A proactive one could detect lightweight patterns on the user's recent turns, surfacing a quiet "you might want to rewind" nudge when they're forward-correcting in circles. These are three of probably many. Pi can already support that kind of grafting through its extension system, but whether a harness is open enough to invite it is itself a stance, and the choice dictates how much the user is allowed to take into their own hands. + +--- + +Speaking of taking things into our own hands. Dex Horthy, founder of HumanLayer, on what makes agents work, lands on a principle that transfers cleanly: you cannot outsource the thinking. The agent amplifies the quality of thinking already done. The human stays in the driver's seat for architectural decisions. Tool choice matters, but so does the posture brought to the session. + +Treating the transcript as addressable state is part of that posture. Pruning, branching, stepping back, summarizing the abandoned branch forward. It's not a power-user feature waiting on a vendor to ship it. It's a stance the user takes about whose conversation this is, and whose thinking it carries. + +And the stakes here are higher than in the editor-focused days. A user in an IDE didn't need a reminder that the past exists, the file wasn't pretending to be a conversation. A chat-shaped session is, and every cue inside it tells you to type the next thing. The LLM's non-determinism sharpens it: forward-correction is the move with no rerun. Typing harder won't reroll the trajectory; only rewinding to a cleaner state and rolling again will. And the cost stacks. Failed attempts stay in context as distractors, biasing what comes next and inflating attention cost. Lost-in-the-middle and context rot are well-documented at this point. Every forward-correction degrades what follows, and the spiral of half-fixes feels like progress until you find yourself asking, with Neo, how deep the rabbit hole goes. The way out isn't another turn. It's a step back. + +What's missing isn't the technology. If Attention is all the model needs, then attention to where you've been in the session, and to the affordances you're given to get there, is what we owe ourselves. + +xoxo, +escape escape. diff --git a/entries/004-dont-conversate-navigate/x-article.html b/entries/004-dont-conversate-navigate/x-article.html new file mode 100644 index 0000000..da753f0 --- /dev/null +++ b/entries/004-dont-conversate-navigate/x-article.html @@ -0,0 +1,24 @@ +

Don't conversate, navigate

+ +

The agent says something off. You correct it. It tries again. You correct it again. Three turns later you're negotiating with a version of yourself from an hour ago, and the apparent way out is to keep talking.

+

Conversation analysts named this a long time ago. Schegloff, Jefferson and Sacks called it the preference for self-correction in repair, and later sharpened next-turn repair as the last structurally provided defense of intersubjectivity. The medium of talk only gives you forward-directed tools for fixing issues. You don't un-say the last turn. You say the next one, hopefully better.

+

LLM chat inherited the entire stance.

+

The lineage is continuous and turn-based at every step. ELIZA, Weizenbaum's 1966 keyword-matching therapist simulator, decomposes a sentence by rule and reassembles a response, one exchange at a time. PARRY, Colby's 1972 simulation of paranoid affect at Stanford, adds internal state and keeps the loop. SmarterChild, the early-2000s ActiveBuddy bot living inside AIM and MSN, embedded the turn-bubble grammar in ambient IM where users already knew the moves. By the time GPT-3 shipped in 2020, "chat with bubbles" wasn't a design decision. It was a default nobody had to make.

+

Worth noticing that GPT-3's first surface wasn't chat. The Playground, OpenAI's web interface for the API, was a text completion box. You wrote text, the model continued it. The conversational shape came later and on purpose. InstructGPT, OpenAI's 2022 RLHF-tuned successor to GPT-3, trained the assistant role into the weights and taught the model to follow instructions in dialogue. ChatGPT productized it. The Chat Completions API baked the turn structure into the wire format itself as a messages array of {role, content} pairs, indexed by position, with no slot for a branch.

+

Three layers converged on the same shape, and each one keeps pushing in the same direction: The UX renders the conversation as a linear scroll. Training optimizes for a helpful next turn, never for revisiting a prior one. The wire format is a flat, ordered array going in one direction - forward.

+

· · ·

+

Backtracking is, of course, not a new ask. Undo, history, branching. Interactive computing has been working the problem of stepping back for half a century, and harnesses sit squarely inside that lineage.

+

Engelbart introduced undo in the 1968 NLS demo as a recovery move on a linear edit stream, the simple "if I make some mistakes, I can back up a little bit." Emacs undo-tree exposed the branching, drew the tree, and let you browse it. Git treated every commit as a node and every branch as a peer of every other. The capability has been there forever. What varies is the affordances the software builds around it: how visible prior states are, how cheap the move back is to invoke, and the fate of any path you leave behind. And on exactly these aspects, harnesses sit on the fence. The conversational framing they inherit pushes hard against the tradition, and the affordances a harness ships can either lean into it or work against it.

+

Pi, an open-source coding harness, takes the navigable line: /tree exposes the session as a tree you can step through, hop between siblings, summarize the abandoned branch forward instead of losing it. Claude Code and Codex CLI, both vendor products, ship the same underlying capability — Claude Code's /rewind, Codex CLI's Esc+Esc — but route it through indirection: rewind is destructive to the active conversation, and any sibling branch requires forking off into a separate session. Going back exists, but framed as recovery rather than navigation. I'd argue the indirection on the vendor side isn't innocent. It's a position with revenue attached. Forward-correction burns tokens, every retry billed at full rate. Sessions belong to the platform, resumption funnels through it, and the framing keeps tooling sticky and harder to leave. The engineering is small. The reluctance isn't accidental.

+

Set the vendor question aside, though, and the open-source story isn't the ceiling either. Pi's /tree is a starting point, not a destination, and the affordances around it have plenty of room to grow. The most basic is naming turns, so the user can point at where they want to go back to instead of guessing or going one-by-one. A reactive one would be a glanceable indicator of session depth and shape, so the user can see how far down a branch they are without invoking anything. A proactive one could detect lightweight patterns on the user's recent turns, surfacing a quiet "you might want to rewind" nudge when they're forward-correcting in circles. These are three of probably many. Pi can already support that kind of grafting through its extension system, but whether a harness is open enough to invite it is itself a stance, and the choice dictates how much the user is allowed to take into their own hands.

+

· · ·

+

Speaking of taking things into our own hands. Dex Horthy, founder of HumanLayer, on what makes agents work, lands on a principle that transfers cleanly: you cannot outsource the thinking. The agent amplifies the quality of thinking already done. The human stays in the driver's seat for architectural decisions. Tool choice matters, but so does the posture brought to the session.

+

Treating the transcript as addressable state is part of that posture. Pruning, branching, stepping back, summarizing the abandoned branch forward. It's not a power-user feature waiting on a vendor to ship it. It's a stance the user takes about whose conversation this is, and whose thinking it carries.

+

And the stakes here are higher than in the editor-focused days. A user in an IDE didn't need a reminder that the past exists, the file wasn't pretending to be a conversation. A chat-shaped session is, and every cue inside it tells you to type the next thing. The LLM's non-determinism sharpens it: forward-correction is the move with no rerun. Typing harder won't reroll the trajectory; only rewinding to a cleaner state and rolling again will. And the cost stacks. Failed attempts stay in context as distractors, biasing what comes next and inflating attention cost. Lost-in-the-middle and context rot are well-documented at this point. Every forward-correction degrades what follows, and the spiral of half-fixes feels like progress until you find yourself asking, with Neo, how deep the rabbit hole goes. The way out isn't another turn. It's a step back.

+

What's missing isn't the technology. If Attention is all the model needs, then attention to where you've been in the session, and to the affordances you're given to get there, is what we owe ourselves.

+

xoxo, +ESCESC.

+ +

· · ·

+ +

Originally published at Engineering Notes.

diff --git a/entries/archived/p4x9-rewind-requires-different-framing/draft.md b/entries/archived/p4x9-rewind-requires-different-framing/draft.md new file mode 100644 index 0000000..55d00bd --- /dev/null +++ b/entries/archived/p4x9-rewind-requires-different-framing/draft.md @@ -0,0 +1,36 @@ +# Don't conversate, navigate + +The agent says something off. You correct it. It tries again. You correct it again. Three turns later you're negotiating with a version of yourself from an hour ago, and the apparent way out is to keep talking. + +Conversation analysts named this a long time ago. Schegloff, Jefferson and Sacks called it the [preference for self-correction in repair](https://www.conversationanalysis.org/schegloff-media-archive/preference-for-self-correction-in-repair-in-conversation-1977/), and later sharpened next-turn repair as the [last structurally provided defense of intersubjectivity](https://www.conversationanalysis.org/schegloff-media-archive/repair-after-next-turn-1992/). The medium of talk only gives you forward-directed tools for fixing issues. You don't un-say the last turn. You say the next one, hopefully better. + +LLM chat inherited the entire stance. + +The lineage is continuous and turn-based at every step. [ELIZA](https://dl.acm.org/doi/10.1145/365153.365168), Weizenbaum's 1966 keyword-matching therapist simulator, decomposes a sentence by rule and reassembles a response, one exchange at a time. [PARRY](https://en.wikipedia.org/wiki/PARRY), Colby's 1972 simulation of paranoid affect at Stanford, adds internal state and keeps the loop. [SmarterChild](https://en.wikipedia.org/wiki/SmarterChild), the early-2000s ActiveBuddy bot living inside AIM and MSN, embedded the turn-bubble grammar in ambient IM where users already knew the moves. By the time [GPT-3](https://arxiv.org/abs/2005.14165) shipped in 2020, "chat with bubbles" wasn't a design decision. It was a default nobody had to make. + +Worth noticing that GPT-3's first surface wasn't chat. The [Playground](https://openai.com/index/openai-api/), OpenAI's web interface for the API, was a text completion box. You wrote text, the model continued it. The conversational shape came later and on purpose. [InstructGPT](https://cdn.openai.com/papers/Training_language_models_to_follow_instructions_with_human_feedback.pdf), OpenAI's 2022 RLHF-tuned successor to GPT-3, trained the assistant role into the weights and taught the model to follow instructions in dialogue. ChatGPT productized it. The [Chat Completions API](https://platform.openai.com/docs/api-reference/chat/create) baked the turn structure into the wire format itself as a `messages` array of `{role, content}` pairs, indexed by position, with no slot for a branch. + +Three layers converged on the same shape, and each one keeps pushing in the same direction: The UX renders the conversation as a linear scroll. Training optimizes for a helpful next turn, never for revisiting a prior one. The wire format is a flat, ordered array going in one direction - forward. + +--- + +Backtracking is, of course, not a new ask. Undo, history, branching. Interactive computing has been working the problem of stepping back for half a century, and harnesses sit squarely inside that lineage. + +Engelbart introduced undo in the [1968 NLS demo](https://www.dougengelbart.org/theDemo) as a recovery move on a linear edit stream, the simple "if I make some mistakes, I can back up a little bit." Emacs [undo-tree](https://www.dr-qubit.org/undo-tree.html) exposed the branching, drew the tree, and let you browse it. Git treated every commit as a node and every branch as a peer of every other. The capability has been there forever. What varies is the **affordances** the software builds around it: how visible prior states are, how cheap the move back is to invoke, and the fate of any path you leave behind. And on exactly these aspects, harnesses sit on the fence. The conversational framing they inherit pushes hard against the tradition, and the affordances a harness ships can either lean into it or work against it. + +[Pi](https://github.com/badlogic/pi-mono), an open-source coding harness, takes the navigable line: `/tree` exposes the session as a tree you can step through, hop between siblings, summarize the abandoned branch forward instead of losing it. Claude Code and Codex CLI, both vendor products, ship the same underlying capability — Claude Code's [`/rewind`](https://code.claude.com/docs/en/checkpointing), Codex CLI's [Esc+Esc](https://developers.openai.com/codex/cli/features) — but route it through indirection: rewind is _destructive_ to the active conversation, and any sibling branch requires forking off into a separate session. Going back exists, but framed as recovery rather than navigation. I'd argue the indirection on the vendor side isn't innocent. It's a position with revenue attached. Forward-correction burns tokens, every retry billed at full rate. Sessions belong to the platform, resumption funnels through it, and the framing keeps tooling sticky and harder to leave. The engineering is small. The reluctance isn't accidental. + +Set the vendor question aside, though, and the open-source story isn't the ceiling either. Pi's `/tree` is a starting point, not a destination, and the affordances around it have plenty of room to grow. The most basic is naming turns, so the user can point at where they want to go back to instead of guessing or going one-by-one. A reactive one would be a glanceable indicator of session depth and shape, so the user can see how far down a branch they are without invoking anything. A proactive one could detect lightweight patterns on the user's recent turns, surfacing a quiet "you might want to rewind" nudge when they're forward-correcting in circles. These are three of probably many. Pi can already support that kind of grafting through its extension system, but whether a harness is open enough to invite it is itself a stance, and the choice dictates how much the user is allowed to take into their own hands. + +--- + +Speaking of taking things into our own hands. Dex Horthy, founder of HumanLayer, on what makes agents work, lands on a principle that transfers cleanly: [you cannot outsource the thinking](https://home.mlops.community/public/videos/12-factor-agents-patterns-of-reliable-llm-applications-dexter-horthy-agents-in-production-2025-2025-08-06). The agent amplifies the quality of thinking already done. The human stays in the driver's seat for architectural decisions. Tool choice matters, but so does the posture brought to the session. + +Treating the transcript as addressable state is part of that posture. Pruning, branching, stepping back, summarizing the abandoned branch forward. It's not a power-user feature waiting on a vendor to ship it. It's a **stance** the user takes about whose conversation this is, and whose thinking it carries. + +And the stakes here are higher than in the editor-focused days. A user in an IDE didn't need a reminder that the past exists, the file wasn't pretending to be a conversation. A chat-shaped session is, and every cue inside it tells you to type the next thing. Non-determinism compounds it: the path not taken would have been _different_, not just unchosen, so abandoning a branch costs information that can't be reconstructed by re-doing the same thing. And the cost stacks. Failed attempts stay in context as distractors, biasing what comes next and inflating attention cost. [Lost-in-the-middle](https://arxiv.org/abs/2307.03172) and [context rot](https://www.trychroma.com/research/context-rot) are well-documented at this point. Every forward-correction degrades what follows, and the spiral of half-fixes feels like progress until you find yourself asking, with Neo, how deep the rabbit hole goes. The way out isn't another turn. It's a _step back_. + +What's missing isn't the technology. If [Attention is all the model needs](https://arxiv.org/abs/1706.03762), then attention to where you've been in the session, and to the affordances you're given to get there, is what we owe ourselves. + +xoxo, +ESCESC. diff --git a/entries/archived/p4x9-rewind-requires-different-framing/research.md b/entries/archived/p4x9-rewind-requires-different-framing/research.md new file mode 100644 index 0000000..081a283 --- /dev/null +++ b/entries/archived/p4x9-rewind-requires-different-framing/research.md @@ -0,0 +1,98 @@ +# Research + +## Rough Idea + +Agentic interaction is framed as conversation, so it inherits conversation's defaults — chief among them, repair-by-next-turn. If something goes wrong, you say the next thing; you don't un-say the last one. Self-correction is the path of least resistance because it's the only path the framing admits. Rewinding — jumping back and re-branching from an earlier point — is a different kind of move on the same transcript, but it requires a different framing of the relationship (the conversation as addressable state, not as a flowing exchange) and different affordances in the product to make it legible. The entry is about that gap: why the conversational framing quietly pushes users toward self-correction, and what rewinding needs from us to become a natural move rather than a power-user escape hatch. + +## Questions + +- How did chat become the default UI for LLMs (the lineage from ELIZA through IM, helpdesk, and chatbots), and what does that inherited framing silently promise — or foreclose — about rewind? +- Why do people default to correcting forward instead of rewinding — cultural dialogue norms, politeness toward the agent, sunk-cost, or a UI that hides earlier state? +- What does the software history of undo as a primitive (Engelbart's NLS, Smalltalk, Emacs undo-tree, Git) teach us about what affordances make rewind a first-class move rather than a recovery mechanism — visible branch points, timeline rails, diffs across branches? +- What alternative framings — document, notebook, planning board, save-states — would change the default move, and what does each buy and cost? +- Across coding harnesses (Claude Code, Codex CLI, Cline, Aider, Pi, Goose, OpenHands, VS Code Copilot), how is rewind exposed — built-in command, extension, delegation to Git, or nothing — and what does the placement say about whether rewind is treated as a product primitive or a recovery afterthought? + +## Sources & Links + +- Weizenbaum, "ELIZA — A Computer Program for the Study of Natural Language Communication between Man and Machine" (CACM, 1966) — https://dl.acm.org/doi/10.1145/365153.365168 +- "The Mother of All Demos" (Engelbart, 1968) — https://www.dougengelbart.org/theDemo +- Schegloff, Jefferson, Sacks, "The Preference for Self-Correction in the Organization of Repair in Conversation" (Language, 1977) +- Schegloff, "Repair After Next Turn: The Last Structurally Provided Defense of Intersubjectivity in Conversation" (AJS, 1992) +- Emacs `undo-tree` package (Toby Cubitt) — https://www.dr-qubit.org/undo-tree.html +- "The Hidden Fork: How Editing Messages in ChatGPT Lets You Branch Conversations" — https://knowledge.buka.sh/the-hidden-fork-how-editing-messages-in-chatgpt-lets-you-branch-conversations/ +- Claude Code Checkpointing / `/rewind` docs — https://code.claude.com/docs/en/checkpointing +- "Add option to rewind conversation without creating a fork" (claude-code issue #9279) — https://github.com/anthropics/claude-code/issues/9279 +- Claude Agent SDK — File checkpointing (`--rewind-files`) — https://platform.claude.com/docs/en/agent-sdk/file-checkpointing +- OpenAI Codex CLI — Features (Esc+Esc rewind & fork) — https://developers.openai.com/codex/cli/features +- Colby, "PARRY" — conversational paranoid-patient simulator (1972), via Wikipedia — https://en.wikipedia.org/wiki/PARRY +- SmarterChild (ActiveBuddy, 2001) — AIM/MSN chatbot bringing bots into ambient IM — https://en.wikipedia.org/wiki/SmarterChild +- OpenAI, "Aligning language models to follow instructions" (InstructGPT, 2022) — https://openai.com/index/instruction-following/ +- Ouyang et al., "Training language models to follow instructions with human feedback" (InstructGPT paper) — https://cdn.openai.com/papers/Training_language_models_to_follow_instructions_with_human_feedback.pdf +- OpenAI, "Moving from Completions to Chat Completions in the OpenAI API" — https://help.openai.com/en/articles/7042661-moving-from-completions-to-chat-completions-in-the-openai-api +- OpenAI, Chat Completions API reference (messages / roles) — https://platform.openai.com/docs/api-reference/chat/create +- Dex Horthy, "12-factor Agents" talk (MLOps Community, 2025) — https://home.mlops.community/public/videos/12-factor-agents-patterns-of-reliable-llm-applications-dexter-horthy-agents-in-production-2025-2025-08-06 +- Dex Horthy on HumanLayer / RPI methodology (Dev Interrupted podcast) — https://linearb.io/dev-interrupted/podcast/dex-horthy-humanlayer-rpi-methodology-ralph-loop +- "Key Takeaways from Dex Horthy on Building Effective AI Agents" — https://medium.com/@isaiahdupree33/key-takeaways-from-dex-horthy-on-building-effective-ai-agents-ef8632c526a4 + +## Observations + +- ELIZA (Weizenbaum, 1966) frames the system as a conversational partner — input sentences are decomposed by keyword rules and reassembled into responses, one exchange at a time. The interaction model is turn-by-turn from its origin; there is no notion of addressing a past turn. +- The lineage from ELIZA to modern LLM chat is continuous and turn-based at every step: PARRY (Colby, Stanford, 1972) extended ELIZA's pattern-matching with internal emotional state (anger, fear, mistrust) but kept the one-utterance-in / one-utterance-out loop; SmarterChild (ActiveBuddy, 2001) moved conversational bots into AIM and MSN Messenger, embedding them in the ambient IM idiom people already used and inheriting its turn-bubble visual grammar; helpdesk and IVR bots of the 2000s–2010s carried the same format into customer-support workflows. By the time LLMs arrived, "chat with bubbles, one turn at a time" was a decades-old cultural default, not a design choice anyone had to make. +- The turn model was not inherent to early LLMs. GPT-3's original product surface (2020) was the Playground — a _text completion_ interface where the user wrote text and the model continued it; prompts were one blob, not a message list. Chat as the default UX is a later, deliberate move: InstructGPT (Ouyang et al., 2022) used supervised fine-tuning on ~13k human demonstrations plus RLHF so the pretrained model learned "conversational format" and "instruction following" as explicit objectives, establishing the `assistant` stance. ChatGPT (November 2022) productised that stance. The Chat Completions API (March 2023) then baked the turn model into the _data structure_ itself: `messages: [{role: "system" | "user" | "assistant", content: ...}]`. OpenAI deprecated the Completions text-only API in July 2023 — the turn-structured `messages` array stopped being one option among several and became the only supported shape. +- Turn semantics are reinforced at three layers that each push _against_ rewind: the product UX (chat bubbles, linear scroll, no addressable past turns), the model's training (alignment objectives optimise for helpful next-turn response, not for state navigation), and the API surface (the wire format is `messages: [{role, content}]` — a linear array per call, with no slots for branch metadata). The API layer is a _wire-format_ constraint, not a _client-state_ constraint: any harness, Pi or Claude Code or Codex CLI, can maintain a client-side tree and project the current root-to-leaf path down to the linear `messages` array per call. Pi does exactly this — its JSONL-with-`parentId`/`leaf` is client-side bookkeeping the model never sees; per call Pi flattens the active path and POSTs a normal Messages request. So nothing in Anthropic's or OpenAI's API _prevents_ Claude Code or Codex from exposing a tree. The divergence between Pi and the vendor harnesses lives in product choice, not API capability. What the three-layer convergence _does_ explain is the cultural gravity: if the UX, the training regime, and the wire format all treat the conversation as linear, representing it as a tree on the client requires a deliberate break from three defaults at once, and most product teams don't. +- Conversation-analysis work (Schegloff/Jefferson/Sacks, 1977; Schegloff 1992) establishes that repair in talk is forward-directed by default: speakers prefer _self-correction_ in their next turn over being corrected by another, and next-turn repair is framed as the _last structurally provided defense of intersubjectivity_ — the medium itself only supplies forward-directed tools for fixing trouble. +- Engelbart's 1968 NLS demo, when showing deletion, is remembered for the phrasing "If I make some mistakes, I can back up a little bit" — undo enters computing framed as a recovery move on a linear edit stream. +- Dex Horthy (HumanLayer, "12-factor Agents") frames a principle that transfers directly: "you cannot outsource the thinking" — AI "amplifies the quality of thinking already done" rather than replacing it, and the human "must remain in the driver's seat for architecture decisions." The position is about cognitive responsibility: good tools and structured checkpoints don't absolve the human from being the one who thinks. +- Emacs `undo-tree` (Cubitt) makes branching history a first-class object in both the data model and the UI: it "treats undo history as what it is: a branching tree of changes," "allows you to recover _any_ past state of a buffer (whereas the standard undo/redo system can lose past states as soon as you redo)," and ships a visualizer that "draws [the tree] for you, and lets you browse around the undo history." +- OpenAI's Codex CLI takes a different stance from Claude Code on the same "go back" gesture: pressing Esc twice "edit[s] your previous user message," with successive Esc presses walking further back, and Enter "fork[s] from that point." The original path is preserved (fork-style), not destroyed (CC-style). Whether there is in-session UI to toggle between the preserved branches is not spelled out in the docs; the described move is rewind-and-fork, and community feature requests (codex issues #11626, #12558, discussion #9618) show users asking for a combined-restore mode closer to Claude Code's `/rewind`. So the two vendors' coding harnesses have converged on a shared "Esc+Esc" input gesture but split on what it _means_: Anthropic picks destructive rewind with conversation/filesystem axes, OpenAI picks fork-on-rewind with files left in the working tree. +- Claude Code `/rewind` is destructive to the active conversation and provides _no in-session branch navigation_: forward messages are removed from Claude's view, and the docs redirect users who want switchable branches to `--fork-session` (a separate session). The session transcript retains prior messages as archival record, which is exactly what issue #9279 names as the problem — "you can never truly 'go back' — you're always creating a new parallel timeline" — i.e., invisible bookkeeping that clutters session listings without being user-navigable. +- Four shapes of "going back" get conflated. The cutting axis is whether the user can navigate between branches in the UI: if yes the tree is a first-class object, if no rewinding is destructive to the active conversation even when bookkeeping persists underneath. + - _Linear undo (classic Ctrl+Z):_ undo discards the redo branch as soon as you make a new edit; past states are lost. + ``` + A — B — C — D (undo twice to B, type E) + ↑ + A — B — E (C, D are gone) + ``` + - _Navigable tree (undo-tree, Pi `/tree`):_ rewinding preserves the forward path as a sibling, and the UI lets the user hop between siblings. `undo-tree` ships a visualizer that draws the tree and accepts keyboard navigation; Pi `/tree` shows a full tree view inside the session with fold/unfold and Ctrl+← → navigation, all history in one JSONL file. (Codex CLI's Esc+Esc preserves the original path on fork but doesn't document an equivalent sibling-navigation UI; it sits between this shape and the next.) + ``` + C — D (old branch, reachable via UI) + / + A — B + \ + E (new branch from B; toggle back to C—D any time) + ``` + - _Destructive rewind (Claude Code `/rewind`):_ the active conversation rolls back; forward messages are removed from Claude's view; the session transcript may retain them as archival record but there is _no UI to navigate between branches_. Sibling branches require a separate command (`--fork-session`) that produces a new session file. + ``` + Before rewind: A — B — C — D (D is current) + After /rewind to B: + A — B (active convo) + (C, D retained under the hood, not user-navigable) + After continuing with E: + A — B — E (from the user's perspective, linear) + ``` + - _Explicit fork (Claude Code `--fork-session`, Pi `/fork`):_ the branch is named as a branch up front and materialises as a separate session/thread. You can switch between sessions at the session-list level, but not inside one. + ``` + A — B — C — D (original session, untouched) + \ + E' (new session, forked deliberately at C) + ``` +- All three of linear undo, destructive rewind, and navigable tree _look_ linear to a casual user, but storage diverges: linear undo erases; destructive rewind erases from view but retains under the hood; navigable tree retains _and_ exposes. Claude Code sits in the middle, which is exactly what drives issue #9279 — users sense the retained bookkeeping (it clutters session resumes) but can't navigate it, so it reads as noise. +- Destructive rewind and explicit fork differ on _where the branch lives_. Claude Code forces the choice up front — destructive rewind in the same session, or explicit fork as a new session. Pi doesn't force the choice: `/tree` is non-destructive navigation _inside_ one session, and `/fork` is a separate, deliberate action when the user wants isolation. +- Placement of rewind across harnesses telegraphs whether the tool treats conversation state as a first-class object, a recovery patch, or somebody else's problem. + - _Claude Code (Anthropic):_ first-class `/rewind` (Esc+Esc) with four actions; conversation and filesystem as separate restore axes; destructive to active conversation; sibling branches only via `--fork-session` (separate session). + - _Claude Agent SDK:_ `--rewind-files ` exposed as a CLI flag with checkpoint UUIDs surfaced in the response stream; docs note this "restores files on disk to a previous state but does not rewind the conversation itself" — file checkpointing is a distinct SDK primitive from conversation rewind. + - _Pi (`pi-mono`, badlogic):_ sessions stored as JSONL with `id`/`parentId`/`leaf` pointer; `/tree` is built in and exposes the tree directly (select any prior node, fold/unfold, continue from there); selecting a user message resubmits as a new branch, non-user moves the leaf as a continuation; `/tree` "changes leaf in the **same session**" while `/fork` creates a new session file; branch-switching can optionally summarize "the path from old leaf back to common ancestor with target"; destructive undo + file-checkpointing are _not_ in core, they come from the community extension `arpagon/pi-rewind`. +- _Addressability and restore semantics are logically independent concerns_ that travel together in most harnesses. Two distinct decisions: _is conversation addressable?_ (can I return to a prior node) and _should going back erase what came after?_ (destructive vs. navigable). Pi splits them — `/tree` makes the session a navigable tree in core, while destructive undo + redo is left to `pi-rewind`. Claude Code bundles them the opposite way: it likely retains enough history under the hood to support navigation but deliberately doesn't expose it — rewind is destructive from the user's view, sibling branches require a separate session. Same underlying shape; very different user contract about what "going back" costs. +- Branches in Pi are _context-isolated_, not context-shared. Per the `/tree` docs, the model only receives the linear path from root to the current leaf (`agent.state.messages = sessionManager.buildSessionContext().messages`); sibling branches exist in storage and in the UI but "are not included in the prompt." Two consequences follow: (a) an arbitrary number of branches can live in the session file without inflating any one context — tree width is effectively free at inference time — and (b) switching branches drops the abandoned branch's messages from the model's working memory. The summarize-on-switch feature exists to bridge this drop: summaries are stored as `BranchSummaryEntry` nodes that become part of the active path, so abandoned exploration can carry forward as compressed context rather than being lost. Claude Code's `--fork-session` achieves similar per-branch isolation by a different mechanism — each session file is its own context — but offers no analogous structured hand-off between sessions. + +## Patterns & Emerging Thesis + +- Pi and Claude Code have taken visibly different bets on the same capability. Both prune context to the active path when the user goes back, so the real axis isn't context cost — retaining siblings in Pi's tree is free at inference time. What differs is _reachability_: Claude Code's `/rewind` is destructive and makes the old branch hard to re-enter without `--fork-session` (a new session file), while Pi's `/tree` lets the user hop back non-destructively and optionally summarize the abandoned branch forward into the active path. That asymmetry changes the friction of every "wrong path, try again" moment — forward-repair stays the cheapest move because CC's rewind costs forward work the user might still want and CC's fork costs a session switch, whereas Pi's tree costs neither. Framing state as a thing you can walk around in, rather than a place you restore to or fork from, reads as a different user contract, not just a different feature. + +## Refined Direction + +The entry is about a specific gap that the conversational framing of agentic interaction quietly opens. Two forces close the gap in the same direction: the UI/UX lineage from ELIZA through IM through ChatGPT (reinforced by instruction-tuning and the `messages`-array API surface) that renders the conversation as a linear stream, and the human default — documented in conversation analysis and felt in every session — to repair forward rather than go back. Together they calcify a mental model where the conversation is _said_, not _navigated_. Harnesses have the capability to offer the navigable view — Pi ships it in core, Claude Code and Codex don't — and that divergence has compounding costs for users whose sessions grow by accretion and whose state-management gradually migrates from their own control to the vendor's summarize/compact/resume machinery. + +The entry's claim is that navigating your own state is a _stance_, not a feature request. It sits alongside Dex Horthy's principle that you cannot outsource the thinking: tool choice matters, but so does the posture the user brings to the session. Forward-correcting everything is an easier conversation and a worse collaboration. Treating the transcript as addressable state — pruning, branching, stepping back, carrying insights forward via summary — keeps the human in the driver's seat in a concrete, token-shaped way. + +Affordances can still go further than Pi does. Two that should be cheap: (a) _reactive_ — immediate visibility into session depth and shape, a "how far down this rabbit hole are we" indicator the user can glance at without invoking any command; (b) _proactive_ — lightweight sentiment/pattern detection on the user's messages to notice when they're forward-correcting repeatedly, and surface a gentle "you might want to rewind" nudge. Sentiment analysis is cheap and well-understood; the harness is the right place for this because it's the only layer that sees the full session state and the user's recent tone at the same time. The direction is not "make rewind exist" — rewind exists — but "make the navigable-state model legible by default, and help the user notice when the forward-only default is failing them."