Tmux is Still Better Than Herdr (Here’s Why)

2026-09-23 · Sam Natale · tutorial · 07:54 · watch on YouTube ↗

developer-toolsterminaltmuxai-agentsgit-worktreesworkmuxherdrneovim

Verdict: the archive's first dissent on Herdr — every "snazzy" agent-multiplexer feature (worktree-per-branch, agent sidebar, dashboard, env copy + node_modules symlink) demoed inside plain tmux via workmux; augment the multiplexer you already know

TL;DR

  • Sam Natale's 8-minute rebuttal (Aug 2026, 19k views) to the "ditch tmux for Herdr" wave: every feature people switch for (spin up a branch plus a fresh git worktree on the fly, a sidebar of agent status, a dashboard over agents and worktrees, automatic .env copying and node_modules symlinking) is shown working inside tmux with workmux.
  • workmux = a worktree manager. It drives the multiplexer you already use (tmux, Zellij, Kitty, WezTerm) and ships none of its own: "it's not trying to reinvent the wheel." The docs frame it as a "giga opinionated zero-friction workflow tool" for running multiple AI agents in parallel.
  • The worktree case stands on its own, no AI needed: when a code review lands mid-feature, stashing or committing and switching loses context. git worktree add gives a clean checkout, but untracked .env files and node_modules don't come along. workmux's repo-level .workmux.yaml declares files.copy / files.symlink plus the panes or windows to open, and a sync command (spoken as "workmux sync files all") re-applies them to every existing worktree.
  • The tmux payoff: because workmux is plain CLI, it composes with a decade of tmux config. A prefix + w display-menu (add, add from branch via fzf, open, remove, dashboard, sidebar) wraps two-line bash scripts, and existing session IDs, keybinds and lazygit popups stay put. Session mode (one tmux session per worktree, windows for editor/server/agent) is his preferred layout.

Key moments

  • [00:00] Cold open on the features — a Branch: prompt spawns a worktree (frame_0001), an OpenCode agent sidebar (frame_0002), and a workmux dashboard of worktrees with git and agent status (frame_0003), then the reveal: "everything I just showed you was actually inside of Tmux."
  • [00:28] What workmux is — a worktree manager across tmux, Zellij, Kitty and WezTerm; docs page on screen (frame_0006).
  • [00:50] Why worktrees — the code-review interruption scenario; stash-and-switch as "cognitive overload" (frame_0010, animated "worktrees" title card at frame_0014).
  • [01:22] Doing it by hand — git worktree add, then manual ln -s node_modules / cp .env (frame_0019, callout "link node_modules").
  • [02:04] .workmux.yaml — files.copy (.env, .env.local), files.symlink (node_modules), panes: nvim (focus) + pnpm run dev horizontal split (frame_0023).
  • [02:47] workmux add testing123 — a new tmux window with Neovim plus Vite dev server; .env copied and node_modules symlinked (frames 0031, 0036).
  • [03:32] Session mode — mode: session with named windows (editor, server, later agent running opencode) (frame_0040, frame_0059).
  • [04:18] Agent sidebar and dashboard — workmux sidebar lists repo, branch and diff per running agent; workmux dashboard shows Agents/Worktrees tabs with status and time (frame_0048).
  • [04:49] Sync files across worktrees ("workmux sync files all") — adds .env.testing to config and it appears in every existing worktree (frame_0055).
  • [05:44] tmux integration — prefix + w display-menu (frame_0062), the bind w display-menu config (frame_0064), fzf branch-picker scripts (frames 0068, 0072).

Hook microscope (0-10s)

  • Frames: 20 at 2 fps

    Read these hook frames with the Read tool:

    • hook_frames/frame_0001.jpg (t=0.0s)
    • hook_frames/frame_0002.jpg (t=0.5s)
    • hook_frames/frame_0003.jpg (t=1.0s)
    • hook_frames/frame_0004.jpg (t=1.5s)
    • hook_frames/frame_0005.jpg (t=2.0s)
    • hook_frames/frame_0006.jpg (t=2.5s)
    • hook_frames/frame_0007.jpg (t=3.0s)
    • hook_frames/frame_0008.jpg (t=3.5s)
    • hook_frames/frame_0009.jpg (t=4.0s)
    • hook_frames/frame_0010.jpg (t=4.5s)
    • hook_frames/frame_0011.jpg (t=5.0s)
    • hook_frames/frame_0012.jpg (t=5.5s)
    • hook_frames/frame_0013.jpg (t=6.0s)
    • hook_frames/frame_0014.jpg (t=6.5s)
    • hook_frames/frame_0015.jpg (t=7.0s)
    • hook_frames/frame_0016.jpg (t=7.5s)
    • hook_frames/frame_0017.jpg (t=8.0s)
    • hook_frames/frame_0018.jpg (t=8.5s)
    • hook_frames/frame_0019.jpg (t=9.0s)
    • hook_frames/frame_0020.jpg (t=9.5s)

  • Word-level transcript (55 words):

  [  0.00s] Okay
  [  0.54s] so
  [  0.56s] I
  [  0.64s] get
  [  0.80s] why
  [  0.96s] you
  [  1.00s] want
  [  1.16s] to
  [  1.42s] ditch
  [  1.42s] Tmux
  [  1.96s] You
  [  1.98s] want
  [  2.14s] to
  [  2.16s] be
  [  2.16s] able
  [  2.34s] to
  [  2.42s] create
  [  2.66s] branches
  [  3.06s] on
  [  3.28s] the
  [  3.36s] fly
  [  3.68s] and
  [  3.86s] create
  [  4.02s] a
  [  4.12s] brand
  [  4.34s] new
  [  4.54s] work
  [  4.72s] tree
  [  4.88s] for
  [  5.08s] it
  [  5.26s] You
  [  5.30s] want
  [  5.44s] a
  [  5.54s] snazzy
  [  5.88s] sidebar
  [  6.34s] where
  [  6.44s] you
  [  6.54s] can
  [  6.68s] see
  [  6.84s] what
  [  6.98s] your
  [  7.08s] agents
  [  7.30s] are
  [  7.50s] doing
  [  7.90s] if
  [  7.96s] they're
  [  8.10s] currently
  [  8.34s] working
  [  8.92s] if
  [  8.98s] they've
  [  9.12s] got
  [  9.22s] a
  [  9.38s] question
  [  9.62s] for
  [  9.96s] you

0.0-3s: Neovim start screen with a Branch: prompt being typed, webcam bottom-right. "I get why you want to ditch Tmux. You want to be able to create branches on the fly and create a brand new work tree for it." ~4-5s: cut to a new pane running a cmatrix-style animation beside Neovim (hook_frames/frame_0010), then ~7-8s: an OpenCode agent session with the sidebar showing two worktrees and diff counts (hook_frames/frame_0016), as he says "a snazzy sidebar where you can see what your agents are doing."

Pattern: steelman, then reversal (contrarian reveal). He lists the audience's reasons for leaving tmux while demoing each feature, then pays it off at 0:21: "I hate to break it to you, but everything I just showed you was actually inside of Tmux." The demo is the proof, and the reveal lands before the viewer realizes they were watching tmux the whole time.

Editorial profile

No scene-change data — likely a static/screen-recorded source.

Terminal screencast with a persistent webcam bottom-right and one full-face aside (frame_0005): real config files and live commands, hand-drawn purple arrows, one animated "worktrees" title card and a pill callout ("link node_modules"). No scene-change data (uniform 6s sampling), consistent with long static screen takes. Brisk, un-padded 8 minutes.

Quotable moments

  • [00:21] "I hate to break it to you, but everything I just showed you was actually inside of Tmux."
  • [00:42] "It's not trying to reinvent the wheel and create its own multiplexer, it's just building onto the one you already own."
  • [03:18] "And that on its own with no AI features is perfect for me."
  • [07:34] "The beauty of workmux is that I can do everything that I currently do in Tmux the way I want to."

Entities mentioned

  • People: sam-natale
  • Companies: GitHub
  • Tools / products: workmux, herdr, tmux, Zellij, Kitty, WezTerm, git worktree, Neovim, OpenCode (Kimi K2.6), pnpm, Vite, lazygit, fzf, Drizzle
  • Places: none

Concepts surfaced

  • augment-over-replace: get agent-era features by layering a tool (workmux) on the multiplexer you already know, instead of migrating to a new one (herdr). You keep years of keybinds, sessions and scripts.
  • worktree-per-task: one git worktree per branch/agent/review so switching never stashes or loses context. The friction is untracked files, fixed by declarative copy/symlink config plus a sync command.
  • CLI-first composability: because every workmux action is a shell command, tmux display-menu, popups and fzf scripts turn it into a personal UI in a few lines.
  • agent-native-multiplexer (counterpoint): agent status panels and dashboards don't require a new multiplexer; an add-on reaches rough feature parity inside tmux.

Transcript

Source: captions.

[00:01] Okay, so I get why you want to ditch Tmux. You want to be able to create
[00:03] Tmux. You want to be able to create branches on the fly and create a brand
[00:04] branches on the fly and create a brand new work tree for it. You want a snazzy
[00:06] new work tree for it. You want a snazzy sidebar where you can see what your
[00:07] sidebar where you can see what your agents are doing, if they're currently
[00:08] agents are doing, if they're currently working, if they've got a question for
[00:10] working, if they've got a question for you, if they're completed. You want to
[00:11] you, if they're completed. You want to be able to open a dashboard where you
[00:13] be able to open a dashboard where you can quickly go through all your agents
[00:14] can quickly go through all your agents that are running and go through all your
[00:16] that are running and go through all your work trees that are open. And you want
[00:17] work trees that are open. And you want to copy your env variables and symlink
[00:20] to copy your env variables and symlink other files that otherwise would need to
[00:22] other files that otherwise would need to be done manually. Well guys, I hate to
[00:23] be done manually. Well guys, I hate to break it to you, but everything I just
[00:24] break it to you, but everything I just showed you was actually inside of Tmux
[00:27] showed you was actually inside of Tmux and it's done with the tool called
[00:28] and it's done with the tool called Workmux. Okay, so what is Workmux? Well,
[00:30] Workmux. Okay, so what is Workmux? Well, Workmux is basically just a work tree
[00:33] Workmux is basically just a work tree manager that works with multiple
[00:35] manager that works with multiple terminal multiplexers. So you can use it
[00:37] terminal multiplexers. So you can use it with Tmux, you can use it with Zellij,
[00:39] with Tmux, you can use it with Zellij, you can use it with the Kitty sessions
[00:41] you can use it with the Kitty sessions and WezTerm sessions. So the idea is
[00:43] and WezTerm sessions. So the idea is it's not trying to reinvent the wheel
[00:45] it's not trying to reinvent the wheel and create its own multiplexer, it's
[00:46] and create its own multiplexer, it's just building onto the one you already
[00:48] just building onto the one you already own, the one you already use on a daily
[00:50] own, the one you already use on a daily basis. But why would you want to use
[00:52] basis. But why would you want to use work trees anyway? Well, I'll give you a
[00:54] work trees anyway? Well, I'll give you a couple scenarios. Let's say you're
[00:55] couple scenarios. Let's say you're currently working on a feature but
[00:57] currently working on a feature but you've also got a branch that's
[00:58] you've also got a branch that's currently waiting for code reviews.
[01:00] currently waiting for code reviews. Well, what are you going to do when the
[01:00] Well, what are you going to do when the code review comes in? Are you going to
[01:02] code review comes in? Are you going to stash your changes for your current
[01:04] stash your changes for your current branch, check out the old branch, make
[01:06] branch, check out the old branch, make the code review changes, and then go
[01:07] the code review changes, and then go back to what you was working on? That's
[01:09] back to what you was working on? That's a lot of cognitive overload, right? Or
[01:11] a lot of cognitive overload, right? Or are you going to commit the changes on
[01:12] are you going to commit the changes on your current branch and then swap to the
[01:14] your current branch and then swap to the other one and then swap back and lose
[01:15] other one and then swap back and lose all the un-staged context? Like I said,
[01:17] all the un-staged context? Like I said, there's a couple of ways to do it, but
[01:19] there's a couple of ways to do it, but work trees, in my opinion, is the most
[01:20] work trees, in my opinion, is the most elegant. So how do you add a work tree
[01:22] elegant. So how do you add a work tree natively? Well, you just do git work
[01:24] natively? Well, you just do git work tree add, the place you want the work
[01:25] tree add, the place you want the work tree, and then the branch you want. And
[01:28] tree, and then the branch you want. And you run that and then now, if you go to
[01:30] you run that and then now, if you go to that location, and now you've got a
[01:31] that location, and now you've got a fresh clean slate where you can work on
[01:34] fresh clean slate where you can work on this branch without interrupting your
[01:35] this branch without interrupting your changes that you're currently working on
[01:37] changes that you're currently working on in the other branch. Now this is cool,
[01:39] in the other branch. Now this is cool, but there are some annoying things. For
[01:40] but there are some annoying things. For example, my environment variables
[01:42] example, my environment variables haven't carried across and my node
[01:44] haven't carried across and my node modules haven't carried across in this
[01:45] modules haven't carried across in this particular project. So there's a couple
[01:47] particular project. So there's a couple ways you could do that, you can link the
[01:48] ways you could do that, you can link the node modules, you can link the
[01:50] node modules, you can link the environment variables. If you're going
[01:52] environment variables. If you're going to change the environment variables,
[01:53] to change the environment variables, then you might want to do a copy
[01:54] then you might want to do a copy instead. But as you can see, there's a
[01:55] instead. But as you can see, there's a couple of extra steps you have to do for
[01:57] couple of extra steps you have to do for each work tree to ensure you've got
[01:58] each work tree to ensure you've got everything you need such as the node
[02:00] everything you need such as the node modules, the environment variable, and
[02:01] modules, the environment variable, and whatever else your project needs to
[02:02] whatever else your project needs to actually run that isn't committed to
[02:04] actually run that isn't committed to get. So, in work mox you can have a
[02:06] get. So, in work mox you can have a repository level configuration.
[02:08] repository level configuration. For example, you might want to copy your
[02:11] For example, you might want to copy your env files in your JavaScript projects,
[02:13] env files in your JavaScript projects, but when you're working with other
[02:14] but when you're working with other languages, you might want to do
[02:15] languages, you might want to do different files and things like that.
[02:16] different files and things like that. So, this is the type of configuration
[02:18] So, this is the type of configuration that you would probably set in your
[02:20] that you would probably set in your repository level, but then you might
[02:21] repository level, but then you might have a global one for just the other
[02:23] have a global one for just the other behaviors that you want to configure
[02:25] behaviors that you want to configure which will get on to later. So, for now,
[02:27] which will get on to later. So, for now, let's just quickly go through what this
[02:28] let's just quickly go through what this does. The way to saying the files you
[02:30] does. The way to saying the files you want to copy and the files you want to
[02:31] want to copy and the files you want to simlink for this project, and then we're
[02:33] simlink for this project, and then we're going to open a new tmux window. A
[02:35] going to open a new tmux window. A window in tmux is just at the bottom
[02:37] window in tmux is just at the bottom here. 1 2 3, these are all different
[02:38] here. 1 2 3, these are all different windows.
[02:40] windows. And then, we're going to tell the
[02:41] And then, we're going to tell the windows we want you to open in one pane
[02:43] windows we want you to open in one pane neovim.
[02:44] neovim. And then, we want you to open pnpm run
[02:46] And then, we want you to open pnpm run dev in another pane. So, if I just do
[02:48] dev in another pane. So, if I just do work mox add, and I put testing 1 2 3
[02:51] work mox add, and I put testing 1 2 3 for example, it should make a branch
[02:53] for example, it should make a branch called testing 1 2 3,
[02:55] called testing 1 2 3, and it should make it as a new window
[02:57] and it should make it as a new window down at the bottom here.
[02:58] down at the bottom here. Let's do it.
[03:00] Let's do it. And as you can see, the new window was
[03:01] And as you can see, the new window was created down at the bottom. We're in the
[03:03] created down at the bottom. We're in the testing 1 2 3 branch. We've got neovim
[03:05] testing 1 2 3 branch. We've got neovim open here, and we've got pnpm run dev
[03:07] open here, and we've got pnpm run dev that happened here. And as you can see,
[03:09] that happened here. And as you can see, if I open this, our env file was copied
[03:12] if I open this, our env file was copied same with this one, and the node modules
[03:14] same with this one, and the node modules were linked. And that is how
[03:16] were linked. And that is how frictionless it is to set up work trees
[03:18] frictionless it is to set up work trees with work mox. And that on its own with
[03:20] with work mox. And that on its own with no AI features is perfect for me. Just
[03:23] no AI features is perfect for me. Just being able to swap when you when
[03:24] being able to swap when you when someone's done a code review, and just
[03:25] someone's done a code review, and just being able to quickly swap back to the
[03:27] being able to quickly swap back to the branch you were on, make the changes,
[03:28] branch you were on, make the changes, and then come back. It's so it's such a
[03:30] and then come back. It's so it's such a breeze. There's no friction at all. My
[03:33] breeze. There's no friction at all. My personal preferred way to do this though
[03:34] personal preferred way to do this though is with sessions because I don't want
[03:36] is with sessions because I don't want tons of tmux windows open. I prefer to
[03:38] tons of tmux windows open. I prefer to have things separate on a session level.
[03:40] have things separate on a session level. So, for that, it's as simple as just
[03:41] So, for that, it's as simple as just changing the mode to session, and then
[03:43] changing the mode to session, and then instead of having the panes configured,
[03:45] instead of having the panes configured, you do windows, and then with the panes
[03:47] you do windows, and then with the panes that you want in each window. So, for
[03:48] that you want in each window. So, for example, when I open a new session now,
[03:51] example, when I open a new session now, in number one, it should have editor
[03:52] in number one, it should have editor which I will run the neovim command.
[03:55] which I will run the neovim command. In the second one, it will have server,
[03:56] In the second one, it will have server, which will run pnpm run dev.
[03:58] which will run pnpm run dev. And that will be in one and two. And
[04:00] And that will be in one and two. And because we wrote focus true here,
[04:03] because we wrote focus true here, this first one will be focused. Let's
[04:04] this first one will be focused. Let's quickly test out. So, this time I'm
[04:05] quickly test out. So, this time I'm doing workmox add testing1234,
[04:08] doing workmox add testing1234, and boom.
[04:09] and boom. As you can see, we have one, two. We're
[04:11] As you can see, we have one, two. We're in the branch testing1234. And if I go
[04:13] in the branch testing1234. And if I go up to two, it's run pnpm run dev here.
[04:15] up to two, it's run pnpm run dev here. Go back to one, neovim is obviously
[04:16] Go back to one, neovim is obviously here. Perfect. And I've not even covered
[04:19] here. Perfect. And I've not even covered everything yet. There's tons of commands
[04:21] everything yet. There's tons of commands here. workmox sidebar, which will open
[04:23] here. workmox sidebar, which will open the sidebar on the side, which will show
[04:25] the sidebar on the side, which will show all the agents that we currently have
[04:26] all the agents that we currently have running. And if I quickly run one, for
[04:27] running. And if I quickly run one, for example, it'll show here the repo name,
[04:29] example, it'll show here the repo name, the branch name, the current diff.
[04:32] the branch name, the current diff. And if we have multiple repos open,
[04:33] And if we have multiple repos open, it'll show them all there. And you can
[04:35] it'll show them all there. And you can easily swap between them by clicking or
[04:36] easily swap between them by clicking or navigating your own tmux way. You can
[04:38] navigating your own tmux way. You can run the command workmox dashboard and
[04:40] run the command workmox dashboard and check out the dashboard, where you can
[04:41] check out the dashboard, where you can see the projects you've got running, the
[04:42] see the projects you've got running, the work and the agents that are running,
[04:44] work and the agents that are running, the worktrees that you've currently have
[04:46] the worktrees that you've currently have uh checked out locally. And it's also
[04:48] uh checked out locally. And it's also got some pretty cool features, such as
[04:49] got some pretty cool features, such as if I add new things to copy in here.
[04:51] if I add new things to copy in here. Let's say I add a new env file,
[04:53] Let's say I add a new env file, env.testing,
[04:54] env.testing, and add to the workmox. Yep, we want to
[04:56] and add to the workmox. Yep, we want to add env.testing as well. I can just do
[04:58] add env.testing as well. I can just do the command workmox sync files all,
[05:01] the command workmox sync files all, and it's going to sync to all of the
[05:03] and it's going to sync to all of the worktrees we currently have for this
[05:05] worktrees we currently have for this repo, and it's going to s-
[05:07] repo, and it's going to s- reapply the symlinks. So, if we swap
[05:09] reapply the symlinks. So, if we swap over now to
[05:10] over now to the end-to-end testing one, for example,
[05:13] the end-to-end testing one, for example, we open up neovim. As you can see, it's
[05:15] we open up neovim. As you can see, it's now added env.testing,
[05:16] now added env.testing, and I didn't have to do anything. So, if
[05:18] and I didn't have to do anything. So, if I later change the configuration of what
[05:21] I later change the configuration of what files need to go to the worktrees, it's
[05:22] files need to go to the worktrees, it's very easy to do that.
[05:24] very easy to do that. Now, I think feature-wise, I've covered
[05:25] Now, I think feature-wise, I've covered what I wanted to. I mean, you can
[05:26] what I wanted to. I mean, you can basically configure workmox to open the
[05:28] basically configure workmox to open the windows exactly how you want. You can
[05:30] windows exactly how you want. You can make it so it'll open it with vertical
[05:32] make it so it'll open it with vertical splits. You can make it look however you
[05:34] splits. You can make it look however you want. But now we're going to add some
[05:36] want. But now we're going to add some sauce. So, obviously, this is tmux, so
[05:38] sauce. So, obviously, this is tmux, so you can do tmux things.
[05:40] you can do tmux things. So, for example, you notice all the
[05:41] So, for example, you notice all the workmox stuff is just terminal commands,
[05:43] workmox stuff is just terminal commands, right? Well, that means you can put
[05:45] right? Well, that means you can put keybinds to it. So, I've got the
[05:47] keybinds to it. So, I've got the keybind, which is my T Tmux prefix key
[05:49] keybind, which is my T Tmux prefix key and W, which then brings up this little
[05:51] and W, which then brings up this little mini menu for me. So, I can just say,
[05:53] mini menu for me. So, I can just say, "Yep, I want to add something." I type
[05:55] "Yep, I want to add something." I type the branch name, and boom, it's just put
[05:57] the branch name, and boom, it's just put me straight in the new branch name. It's
[05:59] me straight in the new branch name. It's run the command in the background, and
[06:00] run the command in the background, and it's obviously got everything set up.
[06:02] it's obviously got everything set up. And yeah, I've basically got everything
[06:03] And yeah, I've basically got everything I need here in this little mini menu
[06:04] I need here in this little mini menu that I made with the Tmux script. I'll
[06:05] that I made with the Tmux script. I'll quickly talk you through that if you
[06:06] quickly talk you through that if you want to have a look.
[06:07] want to have a look. So, for example, in Tmux, you can set up
[06:09] So, for example, in Tmux, you can set up something called display menu, which
[06:11] something called display menu, which basically is something that pops up a
[06:13] basically is something that pops up a little hovering menu where you can set
[06:15] little hovering menu where you can set loads of options, which triggered by the
[06:16] loads of options, which triggered by the second key press.
[06:18] second key press. So, for example, I've added A to do a
[06:20] So, for example, I've added A to do a little pop-up terminal
[06:21] little pop-up terminal that runs the script work mux add
[06:24] that runs the script work mux add branch. And if I quickly go over to that
[06:25] branch. And if I quickly go over to that file, you'll see it's just a bash script
[06:28] file, you'll see it's just a bash script that just prints branch, reads the
[06:30] that just prints branch, reads the branch back that the user enters, and
[06:32] branch back that the user enters, and then just runs the command work mux add
[06:34] then just runs the command work mux add branch. Simple, right? Similarly, I've
[06:37] branch. Simple, right? Similarly, I've got another script that pulls in the
[06:39] got another script that pulls in the branches from GitHub or your Git, and
[06:42] branches from GitHub or your Git, and then lets you select from them if you
[06:44] then lets you select from them if you don't want to create like a fresh one.
[06:45] don't want to create like a fresh one. So,
[06:46] So, basically, all that does is I do add
[06:48] basically, all that does is I do add with branch, it's going to pull the
[06:50] with branch, it's going to pull the branches from GitHub, and this is my dot
[06:52] branches from GitHub, and this is my dot files, so I've got like the main branch
[06:54] files, so I've got like the main branch and the old branch. And as you can see,
[06:56] and the old branch. And as you can see, it's populated them, so I can just
[06:57] it's populated them, so I can just select one, and then it will then open
[06:58] select one, and then it will then open the work the work mux session
[07:01] the work the work mux session with that.
[07:02] with that. And then I've just got another one that
[07:03] And then I've just got another one that just opens the work mux sessions that we
[07:05] just opens the work mux sessions that we have in the current repository as a
[07:07] have in the current repository as a list. So, for example, if I just open it
[07:09] list. So, for example, if I just open it now,
[07:10] now, we only have this one in my dot files,
[07:12] we only have this one in my dot files, but in other ones, I'll have a list here
[07:13] but in other ones, I'll have a list here of all the work trees that I have all
[07:15] of all the work trees that I have all the repo,
[07:17] the repo, and I can quickly swap between the ones
[07:18] and I can quickly swap between the ones that I currently already have open.
[07:20] that I currently already have open. Similarly, I have a dashboard one, which
[07:22] Similarly, I have a dashboard one, which basically just pops a floating window
[07:24] basically just pops a floating window with the dashboard like that.
[07:26] with the dashboard like that. It's similar to what I have for lazy
[07:27] It's similar to what I have for lazy git, which is just like a pop-up
[07:28] git, which is just like a pop-up terminal.
[07:29] terminal. Nice and easy to make.
[07:31] Nice and easy to make. And then the sidebar just literally runs
[07:33] And then the sidebar just literally runs the shell command cuz it's like a
[07:34] the shell command cuz it's like a toggle.
[07:35] toggle. So, yeah, the beauty of work mux is that
[07:37] So, yeah, the beauty of work mux is that I can do everything that I currently do
[07:38] I can do everything that I currently do in Tmux the way I want to. So, I've
[07:40] in Tmux the way I want to. So, I've still got all my Tmux session IDs, so I
[07:42] still got all my Tmux session IDs, so I can swap to you know, all my Teamwork
[07:43] can swap to you know, all my Teamwork sessions
[07:44] sessions and all my Teamwork configuration that
[07:46] and all my Teamwork configuration that I've built over the years of using it
[07:49] I've built over the years of using it can stay in place.
[07:50] can stay in place. So let me know what you think. Are you
[07:51] So let me know what you think. Are you still going to ditch Teamwork or are you
[07:52] still going to ditch Teamwork or are you going to stick around? I'll see you in
[07:53] going to stick around? I'll see you in the next video.

All frames

Total: 80. Hero frames flagged with star.

  • frames/frame_0001.jpg (t=00:00) frames/frame_0002.jpg (t=00:06) frames/frame_0003.jpg (t=00:12) frames/frame_0004.jpg (t=00:18) frames/frame_0005.jpg (t=00:24) frames/frame_0006.jpg (t=00:30) frames/frame_0007.jpg (t=00:36) frames/frame_0008.jpg (t=00:42) frames/frame_0009.jpg (t=00:47) frames/frame_0010.jpg (t=00:53) frames/frame_0011.jpg (t=00:59) frames/frame_0012.jpg (t=01:05) frames/frame_0013.jpg (t=01:11) frames/frame_0014.jpg (t=01:17) frames/frame_0015.jpg (t=01:23) frames/frame_0016.jpg (t=01:29)
  • frames/frame_0017.jpg (t=01:35) frames/frame_0018.jpg (t=01:41) frames/frame_0019.jpg (t=01:47) frames/frame_0020.jpg (t=01:53) frames/frame_0021.jpg (t=01:59) frames/frame_0022.jpg (t=02:05) frames/frame_0023.jpg (t=02:10) frames/frame_0024.jpg (t=02:16) frames/frame_0025.jpg (t=02:22) frames/frame_0026.jpg (t=02:28) frames/frame_0027.jpg (t=02:34) frames/frame_0028.jpg (t=02:40) frames/frame_0029.jpg (t=02:46) frames/frame_0030.jpg (t=02:52) frames/frame_0031.jpg (t=02:58) frames/frame_0032.jpg (t=03:04)
  • frames/frame_0033.jpg (t=03:10) frames/frame_0034.jpg (t=03:16) frames/frame_0035.jpg (t=03:22) frames/frame_0036.jpg (t=03:28) frames/frame_0037.jpg (t=03:34) frames/frame_0038.jpg (t=03:39) frames/frame_0039.jpg (t=03:45) frames/frame_0040.jpg (t=03:51) frames/frame_0041.jpg (t=03:57) frames/frame_0042.jpg (t=04:03) frames/frame_0043.jpg (t=04:09) frames/frame_0044.jpg (t=04:15) frames/frame_0045.jpg (t=04:21) frames/frame_0046.jpg (t=04:27) frames/frame_0047.jpg (t=04:33) frames/frame_0048.jpg (t=04:39)
  • frames/frame_0049.jpg (t=04:45) frames/frame_0050.jpg (t=04:51) frames/frame_0051.jpg (t=04:57) frames/frame_0052.jpg (t=05:02) frames/frame_0053.jpg (t=05:08) frames/frame_0054.jpg (t=05:14) frames/frame_0055.jpg (t=05:20) frames/frame_0056.jpg (t=05:26) frames/frame_0057.jpg (t=05:32) frames/frame_0058.jpg (t=05:38) frames/frame_0059.jpg (t=05:44) frames/frame_0060.jpg (t=05:50) frames/frame_0061.jpg (t=05:56) frames/frame_0062.jpg (t=06:02) frames/frame_0063.jpg (t=06:08) frames/frame_0064.jpg (t=06:14)
  • frames/frame_0065.jpg (t=06:20) frames/frame_0066.jpg (t=06:26) frames/frame_0067.jpg (t=06:31) frames/frame_0068.jpg (t=06:37) frames/frame_0069.jpg (t=06:43) frames/frame_0070.jpg (t=06:49) frames/frame_0071.jpg (t=06:55) frames/frame_0072.jpg (t=07:01) frames/frame_0073.jpg (t=07:07) frames/frame_0074.jpg (t=07:13) frames/frame_0075.jpg (t=07:19) frames/frame_0076.jpg (t=07:25) frames/frame_0077.jpg (t=07:31) frames/frame_0078.jpg (t=07:37) frames/frame_0079.jpg (t=07:43) frames/frame_0080.jpg (t=07:49)