Terminal Kanban Board with Isolated Git Worktrees

What It Is

A terminal-based kanban board combines task management with git worktrees to create isolated development environments for each work item. Unlike traditional kanban tools that live in browsers, this approach integrates directly into the command-line workflow, treating each task as both a tracking item and a separate git workspace.

Git worktrees allow multiple working directories from a single repository, each checked out to different branches. When paired with a kanban interface, developers get a dedicated filesystem location for every task card. Moving a task from “Planning” to “Running” doesn’t just update a visual board - it creates or switches to an isolated worktree where that specific feature or fix lives independently.

The implementation at https://github.com/fynnfluegge/agtx adds tmux session management, automatically spawning terminal windows for each active task. This creates a complete workspace isolation: separate branch, separate directory, separate terminal session.

Why It Matters

Context switching kills productivity. Traditional git workflows require developers to stash changes, switch branches, remember what they were doing, and mentally reload project state. Browser-based kanban boards create additional friction - they exist in a different application space from the code itself.

Terminal-native task management eliminates these gaps. Developers working on multiple features simultaneously can jump between tasks without merge conflicts or lost work. Each worktree maintains its own state, dependencies, and even different versions of files. A bug fix in one worktree doesn’t interfere with experimental refactoring in another.

The integration with AI coding assistants changes how sessions persist. Rather than losing context when closing a terminal, the system can resume exactly where work stopped - same files open, same cursor positions, same mental model. For teams practicing continuous integration, this enables smaller, more focused pull requests since each task naturally stays scoped to its worktree.

Multi-project dashboards address another pain point: developers rarely work in a single repository. Switching between projects typically means changing directories, remembering different build commands, and losing track of what’s in progress. A unified view across repositories keeps all active work visible without mental overhead.

Getting Started

Install the tool from the repository:

# Follow installation instructions in README

Basic workflow starts with creating tasks in the backlog. Each task moves through stages: Backlog → Planning → Running → Review → Done. When moving a task to “Running,” the system creates a git worktree and tmux session automatically.

The typical command structure looks like:

# Work on the task in isolated environment agtx review <task-id> # Moves to review stage agtx done <task-id> # Generates PR and cleans up worktree

Configuration happens through a local config file where themes and project settings live. For teams using Claude or similar AI assistants, the integration allows automated session management - the AI can track which files are relevant to each task and restore that context.

Context

This approach competes with browser-based tools like Jira, Linear, or GitHub Projects. The tradeoff is clear: terminal tools offer speed and integration but lack visual polish and collaboration features. Teams that live in the terminal benefit most - those already using tmux, vim/neovim, or extensive shell scripting.

Git worktrees themselves aren’t new, but manual management is tedious. Creating worktrees, tracking which branch goes where, and cleaning up afterward adds cognitive load. Automation removes that friction, making worktrees practical for everyday development rather than edge cases.

Limitations exist around team coordination. While individual developers gain efficiency, shared visibility suffers compared to web-based boards. Teams need additional communication channels to track overall progress. The tool works best for individual contributors or small teams already comfortable with terminal-first workflows.

Alternative approaches include git stash workflows, feature branch strategies without worktrees, or hybrid solutions that sync terminal state with web dashboards. Each has merits depending on team size, collaboration needs, and existing tooling investments.