Developer workflows aren't static endpoints; they are constant experiments. Here is how my setup evolved from basic text editors to AI-driven terminal orchestration with Herdr, and why everything in tech is circular.
In an industry that moves at breakneck speed, the worst thing you can do is lock yourself into a single workflow and throw away the key. Tech evolves rapidly, and if you are not regularly experimenting with new tools, paradigms, and ways of working, you risk building yesterday's software with yesterday's habits.
My own journey through developer setups has been anything but linear. In fact, if I look back at where I started and where I am today, I am struck by a amusing paradox: we spend years migrating to shiny, feature-packed IDEs, only to end up back in the command line interface. You use an IDE, then you go back to the terminal, which feels so modern yet so incredibly old school. Everything in developer tooling is circular.
The Evolution: Editors, IDEs, and the Terminal Pendulum
When I first wrote code, I started in a basic text editor. It was bare-bones, lightweight, and lacked any real intelligence, but it got the job done. Eventually, as projects grew in complexity, I gravitated towards terminal editors, before making the inevitable leap to full-featured IDEs with rich graphical interfaces, debugging suites, and visual file trees.
Then the generative AI wave hit, and my workflow swung back hard towards the terminal. Tools like Claude Code made raw terminal execution feel vastly faster and more flexible than clicking through menus. I spent months living inside terminal multiplexers like tmux, letting CLI-first models refactor code at lightning speed.
However, pure terminal workflows hit a friction point. I found myself missing visual code context. When an agent was rewriting multiple files, I wasn't reviewing git diffs thoroughly enough because reading complex diffs inside a busy tmux session felt clunky and chaotic. Keeping track of parallel tasks, background processes, and multiple agent threads in terminal windows became a mental chore.
So, I swung back to the visual world. In my post Goodbye VS Code, Hello Antigravity, I wrote about stepping into modern AI-native IDE environments to regain visual control over diffs and codebases. Being able to physically see the code change in real-time made a huge difference to code quality.
My Current Setup: Neovim, Herdr, and Agent Orchestration
Today, I have landed on a hybrid approach that bridges the gap between raw terminal speed and spatial IDE clarity.
To solve my git diff problem, I use Neovim specifically for side-by-side visual diff reviews. For workspace and session management, I use Herdr to structure my terminal environment. Herdr has completely replaced my fragile tmux setups because it was built specifically with modern multi-agent development in mind.
What I love about this current setup is how naturally it handles agentic workflows:
Visual Agent Monitoring: In the left-hand menu, I can immediately see which AI agents are currently running, thinking, or awaiting approval across all my workspaces.
Git Worktree Native: Switching between feature branches and isolation zones is frictionless thanks to built-in worktree and tab management.
CLI Control for Agents: Because Herdr provides its own CLI, I can actually instruct my AI agents to control their own environment. An agent can issue a Herdr CLI command to split a pane, open a new workspace, or launch a secondary task automatically.
Here is a simple example of how an agent can interact with the Herdr CLI to setup an isolated workspace for a sub-task:
# Instructing an agent to spin up an isolated worktree tab
herdr tab create --name "agent-refactor-auth"
herdr pane split --direction right
herdr pane send-keys --target right "claude --prompt 'Refactor JWT rotation logic'"
Hierarchical Memory Graphs across Repositories
Beyond terminal management, the biggest shift in my workflow is how context and memory are structured. In the root containing directory of my projects, I maintain a top-level memory knowledge graph. Each sub-repository within that directory maintains its own local knowledge graph focused on domain-specific architecture and decisions.
When autonomous agents execute tasks inside individual repos, they update the repo-level graph and report back higher-level architectural changes to the primary orchestrator graph in the parent directory. This completely eliminates context drift and keeps multi-repository projects aligned without manual record-keeping.
Never Stop Refining
While this current blend of Neovim diffs, Herdr orchestration, and hierarchical memory graphs feels like the most productive setup I have ever had, it is not the end of the road. No workflow is ever complete or perfect.
Next month, or next year, a brand new paradigm or tool will likely appear that renders parts of this system obsolete. The goal isn't to find a permanent setup and defend it dogmatically; the goal is to remain adaptable. Keep experimenting, keep breaking your workflow, and stay open to whatever comes next.