Overview of 1011: tmux + Terminal Maxxing with Ben Vinegar
In this Syntax episode, Wes and Scott talk with Ben Vinegar about his increasingly “terminal-maxxed” workflow for AI-assisted development. The conversation centers on using tmux as the backbone for remote, agent-driven coding sessions; running agents on dedicated boxes instead of on a local laptop; and building terminal-native tools like Hunk and TermDraw to make coding, reviewing diffs, and diagramming more effective. Ben also shares details about Modem, his company’s AI product management platform, and why he believes the future of agentic coding still needs strong guardrails, especially around security and destructive actions.
Key Topics Discussed
Why Ben moved agentic coding off his laptop
- Running multiple agents locally can slow down a MacBook and hit CPU, memory, and database connection limits.
- Agents often need long-lived, always-on sessions, which are more reliable on:
- a VPS or leased box
- a dedicated machine in the basement
- a remote system reachable via Tailscale
- This setup also solves problems with:
- closing laptop lids
- unstable internet while traveling
- tool approvals interrupting long agent runs
tmux as the core workflow layer
- Ben uses tmux to manage terminal sessions because it supports:
- panes and windows
- detach/reattach from anywhere
- long-running sessions that survive disconnects
- A major advantage over normal terminal splits:
- agents can inspect panes, read logs, and send keys via CLI
- the agent can manage the session directly instead of the user copying between windows
- Ben argues tmux is powerful because it’s:
- old and widely represented in model training data
- open source and portable
- scriptable from agents in a way GUI terminals usually are not
Terminal UIs are more capable than many people think
- Ben pushed back on the idea that the terminal is a poor UI:
- modern terminals support mouse input
- images can be rendered in terminals like Kitty/Ghostty
- tools can build rich interfaces using OpenTUI
- He likes that terminal apps can now have:
- sidebars
- modals
- sticky headers/footers
- buttons and other familiar UI patterns
- He sees terminal-native UX as an emerging “new wave” of tools for agentic workflows.
Tools Ben is building
Hunk
- A terminal-based diff/review tool designed to improve how he reviews AI-generated code.
- Inspired by GitHub-style PR review, but built for the terminal.
- Features include:
- syntax-aware diffs
- responsive layouts
- mouse support
- file navigation
- agent integration via CLI
- The goal is to make reviewing remote-agent code feel more natural and less “vibe-only.”
TermDraw
- A terminal illustration tool for drawing boxes, connectors, labels, and simple layouts.
- Built because Ben wanted a faster way to communicate visual ideas to agents.
- Useful for:
- UI layout sketches
- architecture diagrams
- communicating “put this here” without lengthy textual explanation
- Agents can interpret the drawings well, especially for product/design coordination.
Fresh
- A terminal editor Ben mentions as a more usable, VS Code-like experience in the terminal.
- Designed to reduce the friction of editing on remote machines while still feeling modern.
Security, Guardrails, and “Dangerous Mode”
Ben’s stance on agent permissions
- He is strongly against letting agents run totally unbounded on important systems.
- His reasoning:
- agents can misinterpret instructions
- a “small” request can still lead to destructive outcomes
- business systems and personal systems should not be treated the same
- He prefers:
- isolated boxes
- limited scopes
- explicit approval for dangerous actions
Why “just let it YOLO” is risky
- Ben gives an example from Modem where an agent misunderstood context and created the wrong GitHub issue.
- The broader point: agents can reason themselves into the wrong action if the prompt is ambiguous.
- He argues the industry needs a middle ground between:
- approving every action manually
- and giving agents free rein over everything
The open question
- The hosts discuss whether models will eventually get good enough to know:
- when a destructive action is appropriate
- when it should be blocked
- Ben’s view is cautious:
- some destructive actions are valid in the right context
- but the line is hard to define automatically
Modem: AI Product Management Platform
What Modem does
- Modem is an AI-powered product management platform that:
- ingests product feedback from many sources
- groups and deduplicates issues/topics
- helps teams understand what users are saying
- Sources include:
- support tickets
- Discord
- Slack Connect
- public GitHub issues
- other customer conversation channels
The product’s goal
- Help teams see what customers actually care about:
- recurring complaints
- feature requests
- sentiment around product changes
- bugs that are frustrating users
- It’s meant to reduce the “visibility problem” where feedback gets buried across many tools.
Agentic workflows in Modem
- Modem also includes an agent that can:
- answer questions about product feedback
- create backlog items
- surface issues to the right team
- work in a web/Slack environment
- Ben positions it as a “multiplayer agentic PM” rather than just a chatbot.
Podcasting and Tooling for Editing
State of Agentic Coding
- Ben and Armoroniker run a monthly podcast called State of Agentic Coding.
- They use a professional editor, Sam, to keep turnaround fast.
- Ben built internal tools to speed up review and publishing.
Pod
- A set of extensions/skills for podcast production.
- Can:
- download a Whisper model
- generate transcripts
- identify boring sections to cut
- find interstitials
- generate timestamps/descriptions for YouTube
- Notable idea: the agent is configured for a very specific job, acting like a specialized CLI rather than a general-purpose code assistant.
Visual Media and Terminal Capabilities
- Ben explains that modern terminals can support a surprising amount of visual work:
- PNG rendering
- graphical presentations over SSH
- even video as rapidly changing frames, though that’s inefficient
- For truly visual work, he still often falls back to:
- browser previews
- hosted preview branches
- exposed ports via Tailscale
- But he emphasizes that the terminal is now far more capable than many developers realize.
Notable Takeaways
- tmux is not just about split panes; it becomes much more powerful when agents can inspect and manipulate sessions directly.
- Remote, isolated machines are often a better place to run coding agents than a developer’s main laptop.
- Terminal-native UIs are getting good enough to support serious workflows, not just novelty tools.
- Guardrails matter: agentic systems need permission boundaries, especially for business-critical data.
- Specialized tools beat generic tools when a task is repetitive and domain-specific, like podcast editing or review workflows.
Sick Pick
Ben’s recommendation
- Nirvana the Band the Show the Movie
- Why he likes it:
- blends reality and fiction
- has Nathan Fielder-style energy
- includes time-loop elements
- quirky, clever, and worth checking out
Bonus recommendation
- He also mentions Timecrimes as another strong time-loop movie pick.
Practical Action Items / Ideas to Try
- Try using tmux for long-running AI coding sessions instead of keeping everything local.
- Consider a dedicated remote box for agents if local performance is getting sluggish.
- Use Tailscale or similar networking to make remote agent machines feel local.
- Experiment with:
- terminal diff/review tools
- terminal diagramming tools
- agent-driven CLI wrappers for repetitive workflows
- Re-evaluate how much permission you give to agents, especially on production or personal systems.