Putting it together
A day in the life: how the pieces actually work together.
You've met the tools one at a time. This is the part that turns them into an AI-native way of working — one terminal window where the editor, the shell, Git, and an agent all sit side by side, and nothing is ever lost when you walk away.
This page assumes you've skimmed tmux, Neovim, Shell, and Git. Here we're not learning keys — we're stringing them into a real session.
#The shape of a working session
One window, one project, three or four panes. The editor where you write, a shell where you run things, an agent pane where you delegate or ask questions, and whatever else the task needs — logs, a test watcher, a second shell. tmux holds the layout together and keeps it alive; you move between everything with the same four keys.
#The loop, start to finish
Here's a complete pass at a small task — say, adding a feature to a project. Every step links to the page that teaches the keys.
Open the workspace
Launch Ghostty; a fresh window starts in ~. Jump to (or create) the project's tmux session with Ctrla then T — that's sesh, the session switcher. Type a few letters of the project, hit Enter, and you land in that folder with its layout intact. If you were here yesterday, everything's exactly as you left it.
Lay out the panes
Open the editor: nvim .. Split off a shell beside it with Ctrla then |, and a third pane underneath with Ctrla then - for logs or a dev server. Now you can see the code, run things, and watch output without ever switching windows.
Find your way into the code
In Neovim, press SpaceSpace and type part of a filename to open it, or Space/ to search the whole project's text. Hop to the shell pane with Altl and back with Alth — no prefix, no mouse.
Edit, run, repeat
Make a change in the editor. Flip to the shell and run it — search with rg, find files with fd, run the tests. The grey autosuggestion and CtrlR history mean you retype almost nothing. This tight edit→run loop, all on screen at once, is the whole point of the setup.
Hand the boring parts to an agent
In the shell (or a fourth pane), run claude and describe a chunk of work in plain English — "add a loading state to the form and a test for it." It proposes a plan and a diff; you read the diff, ask for changes if needed, run verification, and only then keep it. Commit first so you can undo in one step if you don't like the result.
Package context for a second opinion
When you want another AI tool or a human reviewer to see the same files, copy an explicit bundle instead of screenshots or loose snippets. From the shell or a tmux pane, run copy-context AGENTS.md src tests; it copies each selected file with its path and contents. In VS Code, press ⇧⌘P and run Copy Opened Files to Clipboard when the open tabs are already the context you want.
Commit what you've got
Pop open lazygit right over your work with Ctrla then g. Stage with Space, commit with c, push with P, quit with q. Small, frequent commits with clear messages — each one is a save point you can return to.
Walk away without losing anything
Done for now? Ctrla then d detaches — close the laptop, the session keeps running. Tomorrow, tmux attach (or the session switcher) drops you back into the exact same panes, editor, and scrollback. That persistence is what makes this feel like a workshop you return to, not a thing you rebuild each morning.
#Which tool for which job
When you're not sure what to reach for:
| Move around / keep things alive | tmux — panes, windows, sessions that survive |
| Write & edit code | Neovim in a pane (quick, keyboard-only) — or VS Code / Cursor for big visual work |
| Run, search, inspect | The shell — rg, fd, z, tests, anything one-shot |
| Save & share work | Git / lazygit — commit early and often; push to GitHub |
| Delegate a chunk of work | An agent (claude) — describe it, read the diff, approve |
| Look something up you've learned | Your knowledge base — ask Claude Code over your own notes |
#Habits that make it click
One session per project — name it, and let tmux keep it warm. Commit before you experiment — then any change, yours or an agent's, is one command to undo. Stay on the home row — the more you lean on Alth/j/k/l, Space in the editor, and CtrlR history, the less the mouse pulls you out of flow.
Use agents for leverage, not autopilot. Ask for a plan before broad edits, keep the task narrow, require verification, and treat the diff as the source of truth. The agent can draft; the human owns the merge.
Nobody runs this whole loop smoothly in week one. Get comfortable in one pane first, then add splitting, then lazygit, then agents. The learning path on the overview orders it for you.
#Going deeper
- The Missing Semester of Your CS Education — MIT's free course on exactly this: shell, editor, tmux, and Git as one workflow.
- Editors & AI — the agent loop Groundwork uses everywhere: describe, plan, edit, review, verify, commit.