My current setup is Terminal Spike, Herdr, code-server, Obsidian, and Pi Edge, connected through Tailscale. I can move from a terminal session to code, from code to a project note, and from that note into a Pi conversation, whether I am at my desk or on my phone.
My connected workspace
Terminal Spike Android · SSH / Mosh Herdr Spaces · Terminals · AgentsFollow links into code and notes ↕
Pi Edge Obsidian ↔ Bridge ↔ Pi on my computerThe computer holds the repositories and runs the tools. The phone gives me several ways to work with them.
What each piece does
| Tool | Its place in my workflow |
|---|---|
| Terminal Spike | My Android entry point for remote terminals, with SSH and Mosh. |
| Herdr | Organises the computer’s terminal spaces, panes, and coding agents. |
| code-server | Gives me a VS Code editor in the browser for reading and editing the remote repository. |
| Obsidian | Holds the project notes, plans, and decisions I return to. |
| Pi Edge | Lets me work with Pi on my computer from inside Obsidian. |
| Tailscale | Connects my devices over a private network when I am away from home. |
Start in Terminal Spike, return to Herdr
Terminal Spike connects my phone to the computer. I resume Herdr and return to the projects and agents already running there. Spaces and tabs give the work structure; agent status tells me where my attention is needed.
That makes Herdr the centre of the terminal side of this setup. I can start work at the desk, detach, and reattach from the phone while the computer and Herdr server remain running. Terminal Spike’s Herdr handling makes that workspace usable through touch.
SSH or Mosh carries the terminal connection. Herdr keeps the terminal workspace on the host. Tailscale provides the network path between devices. Each handles a different part of continuing the work.
Follow links into the editor and notes
A terminal is useful for running agents and commands. For inspecting a source file or reviewing a change, I also use code-server against the repository on the computer.
For the reasoning behind a change, I go to Obsidian. A project note can hold the plan, the decisions behind it, and links back to relevant tools or pages. Terminal Spike supports web URLs and obsidian:// note links, so terminal output can lead directly to the editor or a note on the phone.
The links are part of the workflow: a useful answer should help me reach the relevant file or note again. Obsidian note links require that the destination note exists in the vault on the device opening it; Tailscale does not synchronise the vault.
One set of notes, linked into the repository
On the computer, I use a symbolic link (symlink) to make the project’s Obsidian folder available inside its repository. The vault holds the actual files; the repository’s obsidian entry points to that folder. Opening a plan from the terminal, code-server, or Obsidian therefore reaches the same Markdown file.
For example, with a project folder already created in the vault:
ln -s ~/notes/projects/my-app ~/code/my-app/obsidianThe paths are illustrative. ~/code/my-app/obsidian/plan/next-step.md and ~/notes/projects/my-app/plan/next-step.md now refer to the same file. I can keep source code in Git and plans, decisions, and working notes in Obsidian without copying notes back and forth. The machine-specific link can stay out of version control.
The symlink is a local filesystem connection. It does not synchronise the vault or make a computer path available on the phone. My phone opens the synced vault’s own copy of the note; Tailscale provides access to the terminal, editor, and Pi bridge on the computer. Keeping those jobs separate makes it clearer which file I am editing and how each device reaches it.
Continue from a note with Pi Edge
When the next step starts with a plan or question in Obsidian, I open Pi Edge. I attach the current note or a selection and send it to Pi on the computer. Images can supply context too.
The response stays beside my notes. Attached note links in messages and conversation history let me return to the source, while Terminal Spike and code-server remain available for checking commands and reviewing code.
Pi Edge has its own saved conversations. Moving between these tools gives me access to the same project materials; it does not automatically merge Herdr agent conversations with Pi Edge sessions.
A typical loop
- Open the project note in Obsidian and clarify the next change.
- Use Pi Edge to discuss the note with Pi, attaching the relevant context.
- Switch to Terminal Spike and Herdr to work with terminal agents and commands.
- Open code-server to inspect the implementation and review changes.
- Update the project note with the outcome and links needed for the next session.
I choose the entry point to suit the task. Sometimes I begin with an agent already running in Herdr; sometimes a note is the best place to start.
A short workflow demo
This recording shows image input for remote Codex, opening terminal links in code-server and Obsidian, and customising the extra-key layout in Terminal Spike.
Take the same environment elsewhere
With Tailscale connected on my devices, I can reach the computer’s terminal, browser editor, and Pi bridge away from my home network. The services still need to be running and reachable under the network’s access rules. The computer must stay awake.
This extends my earlier tmux and Termius setup. Terminal Spike is now my phone terminal, Herdr organises the agent workspace, and Obsidian with Pi Edge brings project context into the same loop.