Forem: livecodelife

How I Supercharged My Workflow with Git Worktrees

livecodelife — Sat, 21 Jun 2025 21:15:18 +0000

While venting to ChatGPT about how painful it was to switch branches every time I got feedback on a PR, I discovered Git worktrees. I’d open a PR for a new feature, wait for reviews, then jump onto another task—only to have to git checkout back later when reviewers chimed in. It felt like constantly tearing down and rebuilding my mental context. I mentioned this to ChatGPT, and it suggested trying Git worktrees to keep multiple branches checked out at once. After some research, and talking more with ChatGPT about conventions and pitfalls, I started using this feature at work. Within minutes I had two worktrees live: one for my open PR, and another for my new feature. Now I could let Cursor build out a plan in one window while coding in the other. When comments rolled in on my PR, I simply switched windows without ever dropping my existing work.

After sharing this trick with teammates, I realized most engineers weren’t aware this was even a Git feature. A Reddit post I stumbled upon confirmed that Anthropic’s Claude Code users have been leveraging worktrees to run parallel AI coding sessions. The surprise I was met eith when I mentioned that this was a native git feature it was proof that this capability is still under-hyped.

Where the Pros Are Already Using It

Anthropic (Claude Code) Anthropic’s internal docs walk through creating separate worktrees for different Claude sessions:

  git worktree add ../feature-auth feature-auth
  cd ../feature-auth && claude

You can spin up parallel Claude Code windows—each isolated to its own branch—so AI tasks don’t step on each other’s toes.

Atlassian Sourcetree
Sourcetree added Git worktree support back in 2015, highlighting how useful it is for large projects with multiple branches. Today, both GUI and CLI users tap into worktrees without ever thinking about cloning a repo twice.
VS Code & JetBrains IDEs
Extensions like “Git Worktrees” for VS Code or built-in support in IntelliJ let you create, switch, and manage worktrees right from your editor—making them just as accessible as standard branch checkouts.
Open-Source Projects & Mono-Repos
Big mono-repo teams often need isolated environments for different features or releases. Worktrees let you keep each in its own directory, so you avoid full clones and minimize duplicate storage.

My Top Tips & Tricks

Use Descriptive Folder Names

   git worktree add ../feature-ui-redesign ui-redesign

Name each worktree folder after the branch or task so your terminal prompt and editor window both remind you what you’re working on.

Initialize Every Worktree
Each new directory is like a fresh clone. Remember to run your setup steps—npm install, bundle install, or your language’s build commands—so your tools and dependencies are ready.
One IDE Window & Terminal per Worktree
Keep one editor window and one terminal tab open in each worktree. This makes it crystal clear which branch you’re on and prevents cross-branch file watcher or cache issues.
Avoid Checking Out the Same Branch Twice
Git will refuse to attach the same branch to multiple worktrees. If you need a duplicate, create a temporary branch (git checkout -b feature-copy) or use a detached HEAD (git worktree add -d <path).
Clean Up When You’re Done

   git worktree remove ../feature-ui-redesign
   git worktree prune

Remove worktrees when features ship or batteries die. git worktree list shows all your active worktrees, and prune cleans up any that got deleted manually.

Mind Your Background Processes
If you have build watchers, dev servers, or AI sessions running, keep them confined to their worktree. Stop them before hopping to another to avoid port collisions or CPU overload.
Repair & Move Worktrees Safely
If you accidentally move a worktree folder, run git worktree repair <new-path> in the main repo. Use git worktree move <old-path> <new-path> if you want to rename or relocate cleanly without breaking links.

Wrapping Up (and What to Watch Out For)

Git worktrees turned my PR-feedback treadmill into a smooth flow of parallel tasks. With Cursor (or any AI assistant) running in one worktree and my coding in another, I shaved hours off context switches every day. Plus, when bugs surface post-deploy, I’ve still got that worktree handy with all the latest changes, ready for a quick fix.

Caution: It’s tempting to spin up a dozen worktrees and juggle every task at once. That can splinter your focus and lead to burnout. Start with a couple—maybe one for active features and one for hotfixes—and scale consciously. A clean, focused workflow beats a cluttered one every time.

Give it a try on your next multi-branch stint. Clone once, work everywhere.

Roo Code Workflow: Build a Free, Always-On LLM-Powered Dev Assistant

livecodelife — Mon, 09 Jun 2025 23:44:33 +0000

TL;DR: I’ve been running a local Roo Code setup 24/7—two weeks straight—using only free tiers (Gemini + OpenRouter) and a custom “Think” mode for planning. Here’s how to replicate it, why it’s cost-efficient, and key tweaks I learned from the community (this setup reached #1 on r/RooCode for 3 days).

Why This Setup Exists

Cost Control: Free tiers (Gemini via Google AI Studio, OpenRouter’s free models) let you run thousands of daily LLM calls with zero spend.
Specialized Modes: Assign each model to the task it does best—planning, architecture, code, debugging—so you don’t waste expensive tokens.
“Think” Mode: A custom reasoning agent that breaks complex tasks into bullet-proof plans, cutting down trial-and-error.

Whether you’re prototyping a SaaS MVP, experimenting with AI-driven features, or just love playing with LLMs, this guide will get you up and running in under 20 minutes.

1. Prerequisites

You’ll need:

VS Code + Roo Code extension
A free Google AI Studio API key for Gemini
A free OpenRouter API key (Buy $10 of credits for 1,000 free calls/day)

Create a Gemini provider profile through the Roo UI in VS Code and paste your API key in the specified field.

Do the same for OpenRouter, or just setup OpenRouter when you install the Roo Code extension. Roo makes this easy!

2. Modes & Model Allocation

Mode	Role	Model(s)	Source
Orchestrator	Breaks tasks into subtasks	Gemini	Google AI
Think	Detailed reasoning & edge-case planning	Gemini	Google AI
Architect	High-level design & module outlines	DeepSeek R1 0528	OpenRouter
Code	Snippet & module generation	DeepSeek V3 0324, Qwen3 235B, Mistral Devstal Small	OpenRouter
Debug	Bug-fix suggestions & refinements	Same as Code	OpenRouter

Pro tip: If DeepSeek V3 feels sluggish, switch to Qwen3 for straightforward code. Use Devstral Small when you need more context in your prompts.

3. Step-by-Step Setup

A) Create the “Think” Mode

Open Roo Code → Custom Modes → Add “Think”
Role:

   You are a specialized reasoning engine. Analyze tasks, break them into steps, list edge cases, and return a markdown-structured plan. Do NOT write final code.

Instructions:

   - Use markdown headings and lists.
   - Start with a task summary, then steps, then challenges.
   - Output only the reasoning plan.

B) Tweak Your Orchestrator Prompt

In your Orchestrator’s custom instructions, replace step 1:

1. When given a complex task, break it into logical subtasks. If a subtask needs deep analysis, call `new_task` to delegate to “Think” mode first. Use its structured output to guide subsequent steps.

And update step 2’s first sentence:

2. For each subtask (directly or after using “Think”), use `new_task` to assign it to Architect, Code, or Debug.

C) Configure Your Mode Profiles

Gemini profile → Orchestrator + Think
OpenRouter – Code-Debug-Plan → Architect, Code, Debug

4. Running Your First Task

Generate a PRD: Ask any LLM to outline your project scope.
Feed the PRD into Orchestrator—watch it delegate:

Off to Think for edge-case plans
Off to Architect for module sketches
Off to Code for implementation
1. Review & Iterate: Use Debug mode to fix any errors, then loop back.

5. Tips, Tricks & Community Q&A

Q: How do I reduce inference costs?
A: Use “Think” mode to pre-plan—fewer back-and-forth code iterations = fewer tokens.

Q: Are these models the best?
A: Yes and no. There are more "premium" paid models available, but these models do well on benchmarks and have been shown to have good outputs. They also give you a lot more bang for your (non-existent) buck

Q: Does this replace human input?
A: No—LLMs still need good prompts. Think of this as an assistant that you guide. The more precise your PRD and tasks, the better the output.

6. What’s Next

This is just the start. There are a lot of enhancements you can add like Roo Commander and several Memory Bank strategies to make Roo work even better. Try different things and see what works for you

Enjoyed this? Share your own modes, tips, or questions in the comments, or drop me a note on LinkedIn/Reddit.