Terminal Kanban with Git Worktree Integration

git worktree add ../feature-auth feature/authentication
kanban move "Implement OAuth" in-progress

These two commands represent a workflow shift that eliminates context switching between task management and code development. The first creates a separate working directory for a Git branch, while the second updates a task’s status in a terminal-based kanban board. When integrated, they form a development environment where project tracking and version control operate in lockstep.

Bridging Project Management and Version Control

Terminal kanban tools like taskell, kanban-cli, and git-kanban store tasks as plain text files within repositories. This approach keeps project state alongside code, making tasks version-controlled artifacts rather than external metadata. Git worktrees extend this integration by allowing multiple branches to exist as separate directories simultaneously, each representing a distinct task or feature in development.

The technical implementation varies across tools. git-kanban stores tasks in a .kanban directory as YAML files, with each task containing metadata like status, assignee, and branch references. When a developer creates a worktree for a specific branch, the kanban system can automatically transition the associated task from “To Do” to “In Progress.” Conversely, merging a branch can trigger task completion.

# .kanban/tasks/auth-feature.yml
id: auth-001
title: Implement OAuth
status: in-progress
branch: feature/authentication
worktree: ../feature-auth
created: 2024-01-15

This file-based approach enables Git hooks to maintain synchronization. A post-checkout hook can update task status when switching worktrees, while a post-merge hook can archive completed tasks. The entire task history becomes part of the repository’s commit log, providing an audit trail of project evolution alongside code changes.

Workflow Transformation in Practice

Traditional kanban boards exist separately from development environments, requiring manual updates that developers often neglect. Terminal integration removes this friction by embedding task management into existing command-line workflows. A developer working on multiple features no longer needs to remember which branch corresponds to which task or manually update a web-based board after completing work.

The worktree integration proves particularly valuable for parallel development. Instead of stashing changes and switching branches repeatedly, developers maintain separate directories for each active task. Each worktree has its own working directory and index, but shares the same repository history. This means compiling one feature doesn’t require abandoning work on another.

# List all active worktrees and their associated tasks
git worktree list
kanban list --filter=in-progress

# Output shows parallel work streams
../feature-auth        feature/authentication  [auth-001]
../bugfix-validation   bugfix/form-validation  [bug-042]
../refactor-api        refactor/api-cleanup    [tech-015]

Performance remains efficient because worktrees share the .git directory. Only working files are duplicated, not the entire repository history. A repository with 10,000 commits might occupy 500MB, but each additional worktree adds only the size of the working tree itself, typically under 50MB for most projects.

Adoption Patterns and Tool Evolution

The terminal kanban ecosystem continues expanding as developers recognize the benefits of text-based project tracking. Tools like gh-dash integrate GitHub issues into terminal interfaces, while jira-cli brings enterprise project management to the command line. These tools increasingly support worktree awareness, detecting active branches and suggesting task transitions.

Custom implementations using shell scripts and Git hooks provide flexibility for teams with specific workflows. A simple bash script can parse kanban files, create worktrees, and update task status in a single command:

#!/bin/bash
# kanban-worktree.sh
task_id=$1
task_data=$(yq eval ".tasks[] | select(.id == \"$task_id\")" .kanban/board.yml)
branch=$(echo "$task_data" | yq eval '.branch' -)
git worktree add "../$branch" "$branch"
yq eval -i ".tasks[] |= select(.id == \"$task_id\").status = \"in-progress\"" .kanban/board.yml
git add .kanban/board.yml && git commit -m "Start work on $task_id"

The convergence of task management and version control reflects broader trends toward developer-centric tooling. As remote work increases, teams seek solutions that maintain project visibility without disrupting individual workflows. Terminal-based systems offer this balance, providing structure without the overhead of GUI applications or web dashboards.

Future development will likely focus on cross-repository task tracking and improved visualization within terminal environments. Projects like lazygit already demonstrate that complex Git operations can have intuitive text-based interfaces, suggesting similar potential for integrated kanban systems.