<< NOTES

published

J2: continuation of the dotfiles reflection. pick up from the August 2025 endpoint and follow the repository through the current HEAD, with particular attention to the shift from editor-integrated AI toward agent-oriented terminal workflows.

Dotfiles Repository Evolution Timeline (Continuation: 2025-2026)

The previous reflection ended with a modern Neovim-centered workstation: LazyVim, Mason, DAP, mise, Alacritty, tmux, and the first signs of AI-assisted development.

The next phase is less about adding another tool and more about making the tools cooperate. The repository gradually moves the center of gravity out of individual applications and into the workflow around them: project sessions, pickers, pane state, keymaps, and eventually agent state.

This continuation covers 119 commits from August 22, 2025 through July 29, 2026. The repository reaches 386 total commits. Across the continuation, 35 tracked files changed, with approximately 1,649 lines added and 619 removed. The largest changes are not package upgrades; they are reorganizations of Neovim and tmux around a more deliberate interaction model.

Late 2025: from a configured editor to a composed workflow

August 2025 — tmux becomes the project switchboard

The period immediately after the previous reflection is dominated by tmux launcher experiments:

This is an important change in scope. tmux is no longer only a multiplexer configuration; it is becoming a lightweight project operating system.

September-October 2025 — Neovim modularizes, then negotiates its interfaces

The large Neovim configuration is broken out into individual Lua modules. nvim/init.lua drops from roughly 348 lines at the August endpoint to 24 lines at the current HEAD, while behavior moves into nvim/lua/plugins/ and nvim/lua/customs/.

The modularization makes experimentation cheaper, and the commit history shows that experimentation happening in public:

The pattern is not “pick one plugin and stay loyal.” It is closer to interface design: try a workflow, notice its friction, keep the useful parts, and preserve a recognizable command vocabulary even when the implementation changes.

October 2025 — AI moves out of the main editor surface

The AI story takes a noticeable turn:

This is not a rejection of AI. It is a separation of concerns. Neovim keeps low-friction completion; the larger agent interaction moves toward a dedicated process and terminal session rather than occupying the editor’s primary interface.

The emerging division of labor looks like this:

Neovim                         terminal / tmux
--------                       --------------
completion                     project session
LSP + DAP                      long-running agent
quick edits                    agent context + output
local navigation               session switching

November-December 2025 — personal commands become workflow APIs

The repository starts encoding domain-specific actions instead of only configuring generic tools.

The important evolution is that the editor begins to expose small, composable commands for real work. These commands are not just plugin toggles; they are personal workflow primitives.

2026: cleanup, consolidation, and agent orchestration

February-March 2026 — custom behavior is separated from plugin configuration

The winter cleanup removes several experiments and clarifies ownership:

This is a recurring dotfiles cycle: add behavior quickly, live with it, then move it to the smallest place that explains why it exists.

April 2026 — the documentation and picker surfaces consolidate

April contains a second major Neovim simplification:

The result is a thinner bootstrap and a more legible system. The README becomes part of the user interface: it explains the layers, the installation links, and the keymap contract.

May-July 2026 — maintenance becomes the background, agents become the foreground

May and early July are mostly refinement: plugin locks, tmux predicate cleanup, terminal key reporting, Node 26, pane workflow improvements, and small aesthetic adjustments.

Then July changes the character of the repository.

The Herdr agent-picker experiment

On July 18, a separate agent picker is added to tmux. It initially uses Herdr as the agent backend and provides:

The first implementation creates separate launcher scripts and a small Herdr configuration. Almost immediately, the design is folded into the existing session picker.

The unified picker joins two previously separate lists:

active tmux sessions + project directories
                    │
                    ├─ normalize project → session name
                    │
                    ├─ attach agent status when present
                    │
                    └─ one fzf picker
                         ├─ Return → ordinary session switch
                         └─ F1/F2/F3 → jump to a selected window

The repository does not end up with an “agent picker beside the session picker.” It ends up with a session picker that knows agents exist. That distinction matters: the project remains the primary unit, while the agent becomes state attached to the project.

Herdr gives way to native Pi state

The Herdr-specific path is short-lived. Within the same July burst:

The implementation is revealing. The system no longer needs to ask a separate agent service to tell the terminal what is happening. The agent reports its lifecycle into tmux, and tmux makes that lifecycle visible where project navigation already happens.

The final architecture is roughly:

Pi agent process
      │
      │ writes pane-local state
      ▼
tmux pane options: @pi-agent / @pi-state
      │
      ├─ tmux hooks mark completed work as seen
      ├─ session picker renders status
      └─ fzf selects project/session/window
            ▲
            │
     Alacritty + skhd key translation

This is the clearest sign of the new era: the agent is treated as a participant in the workstation, not as a feature embedded in the editor.

Agent-use evolution

Across the continuation, the AI/agent workflow passes through several distinct shapes:

  1. Chat inside Neovim — Avante and Copilot Chat experiment with making the editor itself the agent surface.
  2. Autocomplete inside Neovim — Copilot is retained as a lightweight completion source, while the larger conversation is removed from the main editing UI.
  3. Dedicated terminal agent — the agent gets a long-lived process, a tmux pane, and a project session rather than a transient editor panel.
  4. Agent-aware navigation — the session picker displays whether an agent is working, done, or idle.
  5. Agent lifecycle as local state — Pi writes state to tmux; tmux owns visibility, focus, and navigation.

The trajectory is therefore not simply “more AI.” It is a move toward agent ergonomics:

The answer encoded by the current dotfiles is: put the agent beside the project, give it a visible lifecycle, and make the existing session switcher the control surface.

Key evolution themes

  1. Editor configuration → workflow composition
    Neovim remains important, but tmux, Alacritty, skhd, and project launchers now form one system.

  2. AI panel → autonomous session
    The editor keeps completion. Longer-running agent work moves into a process that can persist in tmux.

  3. Separate tools → shared interaction language
    Picker commands, navigation keys, window jumps, and status indicators are repeatedly aligned across layers.

  4. External status service → local terminal state
    The Herdr experiment demonstrates the desired behavior, then native Pi/tmux state removes the extra dependency.

  5. Configuration sprawl → modular ownership
    The Neovim bootstrap gets smaller while plugin behavior, domain helpers, aliases, and keymaps gain clearer boundaries.

  6. Keymaps as implementation detail → keymaps as product surface
    The keymap reference is created, revised, and finally consolidated into the README because the interaction model is now part of the system’s design.

  7. Experimentation remains a feature
    fzf-lua versus Snacks, Avante on and off, layoutizer versus session launchers, and Herdr versus native Pi state all show a willingness to reverse course when the workflow becomes simpler.

Current state (July 2026)

The dotfiles now describe a workstation organized around project sessions and agent-aware navigation:

The repository has moved a long way from a 2013 collection of shell and Vim files. The latest evolution is not another migration from one tool to another. It is the emergence of a small personal operating environment in which projects, panes, editors, and agents share state.

The next likely frontier is not obvious from the history. The system has reached the point where the interesting questions are behavioral: how agent state should notify, how sessions should be resumed, how context should persist, and how much orchestration belongs in tmux versus Pi itself.

— <|°_°|>