agentleFS
tovrleaftovrleaf/openkata/skills/git-worktree/SKILL.md

git-worktree

Skill1 starsChanged 13 days agoMITView on GitHub

Creates, lists, and removes git worktrees to manage parallel workspaces. Activate when the user needs to work on multiple branches simultaneously, run parallel tasks in isolation, or when an agent needs its own workspace. Also activate when the user says "worktree", "parallel branch", "work on two things at once", or "run these in parallel".

30 other projects use a version of this.

Adopted by

Most recently taken up by

Used with

Projects with it also use agent-native-architecture, document-review and 5 more.

Other files people use alongside this one.

Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
  • CodeWithBehnamSkill

    agent-native-architecture

    Build applications where agents are first-class citizens. Use this skill when designing autonomous agents, creating MCP tools, implementing self-modifying systems, or building apps where features are outcomes achieved by agents operating in a loop.

    Also in 3 projects that use this

  • CodeWithBehnamSkill

    document-review

    This skill should be used to refine brainstorm or plan documents before proceeding to the next workflow step. It applies when a brainstorm or plan document exists and the user wants to improve it.

    Also in 3 projects that use this

  • MicrosoftSkill

    git-commit

    Stage user-selected paths, confirm the exact staged set, and create one local Conventional Commit, or generate a commit message for staged changes without committing. Use when you want a guarded commit or a ready-to-paste message.

    Also in 3 projects that use this

  • OpenAISkill

    brainstorming

    You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.

    Also in 3 projects that use this

  • BlockSkill

    frontend-design

    Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

    Also in 4 projects that use this

  • GoogleSkill

    code-review

    Adversarial systems, concurrency, memory-model, and architecture code review protocol. Use this skill whenever asked to review code, PRs, diffs, or branches in Filament.

    Also in 4 projects that use this

The file

We split this skill into the rules it gives an agent

9 rules. 0 are common, 7 are distinctive, and 2 are very specific to this project.

  • 0

    Common

    Most of the 25 edited versions we read keep these.

  • 7

    Distinctive

    This author's own choices. Worth a look.

  • 2

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Run these two commands and compare output:

    line 25
  2. Distinctive:

    If the outputs differ, you are inside a worktree.

    line 30
  3. Very specific:

    If exit code is non-zero, add .worktrees/ to .gitignore before proceeding.

    line 39
  4. Distinctive:

    If the branch already exists:

    line 55
  5. Very specific:

    Add .worktrees/ to .gitignore (one-time setup)

    line 98
  6. Distinctive:

    Remove worktrees after merging — they are temporary

    line 99
  7. Distinctive:

    Does NOT manage PRs or merges (use create-pr skill)

    line 124
  8. Distinctive:

    Does NOT handle CI/CD or deployment

    line 125
  9. Distinctive:

    Does NOT replace branch workflow — extends it with parallelism

    line 126

“Common” is measured: kept by at least 6 in 10 of the 25 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Git Worktrees

Worktrees give each parallel task its own filesystem while sharing one repository. Every worktree has a branch; every parallel agent gets its own worktree.

Steps

Pre-flight (mandatory before any worktree creation):

  1. Run these two commands and compare output:
    git rev-parse --git-dir
    git rev-parse --git-common-dir
    If the outputs differ, you are inside a worktree. Stop immediately and warn: "You are already inside a worktree. Switch to the main checkout first." Do not proceed.
  2. Run:
    git check-ignore -q .worktrees
    If exit code is non-zero, add .worktrees/ to .gitignore before proceeding.

Both checks are mandatory. Never skip them — nested worktrees corrupt repository state.

  1. Create the worktree — Run:
    git worktree add .worktrees/<name> -b <branch-name>
    Convention: name the directory after the task, prefix the branch by type:
    git worktree add .worktrees/fix-auth-bug -b fix/auth-bug
    git worktree add .worktrees/redesign-nav -b feature/redesign-nav
    If the branch already exists:
    git worktree add .worktrees/<name> <existing-branch>
  2. Work in the worktree — cd .worktrees/<name> and operate normally. Run the project's tests after entering to confirm a clean baseline.
  3. List active worktrees — After creating worktrees, always run:
    git worktree list
    This confirms the worktrees are set up correctly and shows the full set of active workspaces.
  4. Merge results — When work is complete:
    • Push the branch and create a PR, or
    • From the main checkout: git merge <branch-name>
  5. Remove the worktree — After merging, always run both commands:
    git worktree remove .worktrees/<name>
    git branch -d <branch-name>
    Both are required — worktree remove detaches the directory, branch -d deletes the branch. If the directory was deleted manually, run git worktree prune instead.

Parallel Execution Pattern

For batch operations across multiple tasks, see parallel-execution.md.

Conventions

  • Store worktrees in .worktrees/ at the project root
  • Name directories after the task (not the branch)
  • Branch naming: use a type prefix matching your project's convention (e.g., feature/, fix/, release/, experiment/)
  • Add .worktrees/ to .gitignore (one-time setup)
  • Remove worktrees after merging — they are temporary

Gotchas

  • Same branch twice — Git refuses to check out a branch in two worktrees simultaneously. Use a different branch name or detach HEAD.
  • Shared refs — All worktrees share .git/refs. A tag or remote update in one is visible in all.
  • Shared stash — git stash is global. Name stashes: git stash push -m "worktree: description"
  • Hooks — Git hooks are shared (.git/hooks). A pre-commit hook runs in whichever worktree triggers it.
  • IDE state — Open each worktree as a separate project window to avoid conflicts.
  • Skipping pre-flight — Agents consistently skip pre-flight checks when eager to create worktrees. The guards exist because nested worktrees corrupt state and unignored .worktrees/ pollutes git status.

Boundaries

  • DOES create, list, and remove worktrees
  • DOES establish branch naming conventions for worktrees
  • DOES demonstrate parallel execution patterns
  • Does NOT manage PRs or merges (use create-pr skill)
  • Does NOT handle CI/CD or deployment
  • Does NOT replace branch workflow — extends it with parallelism

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.