Git Worktree: Fitur Lama yang Jadi Berguna Lagi di Era AI Coding Agent

AI agent lu mau ngoprek codebase? Jangan langsung dilepas di branch kerja utama.

Ini bukan karena gua anti-AI coding. Justru sebaliknya: makin sering lu pakai Claude Code, Codex, Copilot, atau agent lain, makin penting lu punya “kandang” kerja yang jelas. Salah satu cara paling simpel buat itu bukan tool baru yang mahal, tapi fitur Git lama bernama git worktree.

Git worktree memungkinkan satu repository punya beberapa folder kerja yang terhubung ke branch berbeda. Buat developer, ini berguna buat hotfix, review PR, eksperimen paralel, dan sekarang: memberi AI coding agent ruang kerja sendiri tanpa mengacak perubahan utama lu. Intinya, worktree bukan pengganti branch hygiene, tapi guardrail kecil yang bikin workflow paralel lebih aman dan lebih enak dipantau.

Apa itu git worktree?

Git worktree adalah fitur Git untuk mengelola banyak working tree dari satu repository. Menurut dokumentasi Git, satu repository bisa punya lebih dari satu working tree, sehingga lu bisa checkout lebih dari satu branch di waktu yang sama.

Kalau biasanya lu cuma punya satu folder project seperti ini:

my-app/
  .git/
  src/
  package.json

Dengan worktree, lu bisa punya struktur seperti ini:

my-app/                 # branch main
my-app-ai-refactor/     # branch experiment/ai-refactor
my-app-hotfix-login/    # branch hotfix/login

Semua folder itu tetap nyambung ke repository yang sama, tapi masing-masing bisa berada di branch berbeda. Jadi lu nggak perlu checkout bolak-balik, stash perubahan setengah matang, atau clone repo berkali-kali cuma buat kerja paralel.

Kenapa fitur lama ini mendadak relevan lagi?

GitHub baru-baru ini membahas ulang worktree sebagai workflow yang makin relevan karena cara kerja developer berubah. Dulu, banyak developer bekerja linear: bikin branch, kerjain fitur, buka pull request, merge, lanjut task berikutnya.

Sekarang polanya lebih paralel. Lu bisa:

lagi ngerjain fitur utama, tapi ada hotfix mendadak;
review branch teammate tanpa nutup file yang lagi lu edit;
menjalankan satu AI agent buat refactor kecil;
menjalankan agent lain buat bikin test;
membandingkan dua pendekatan implementasi dalam folder berbeda.

Masalahnya, workflow paralel gampang bikin folder kerja berantakan. AI agent bisa nambah file, ngubah dependency, atau menyentuh bagian yang lu nggak minta. Kalau semua itu terjadi di branch utama lu, review jadi capek dan rollback jadi rawan.

Worktree memberi batas fisik yang gampang dilihat: “task ini ada di folder ini, branch ini, tujuan ini.” Itu kecil, tapi efeknya besar buat clarity.

Masalah yang sering kejadian tanpa worktree

Lu mungkin pernah ada di situasi kayak gini:

Lu lagi ngerjain fitur, lalu harus checkout branch lain buat fix production.
Git nolak checkout karena ada uncommitted changes.
Lu stash dulu, pindah branch, fix, balik lagi.
Pas unstash, conflict muncul di file yang tadi rasanya aman.

Untuk kerja manual saja ini sudah ganggu. Tambahin AI agent ke tengah workflow, masalahnya naik level. Agent bisa membuat banyak perubahan cepat, tapi belum tentu semuanya relevan. Kalau lu belum siap commit dan belum siap buang, branch utama jadi tempat eksperimen liar.

Gua lebih suka memandang worktree sebagai ruang isolasi ringan. Bukan sandbox security. Bukan container. Tapi cukup untuk memisahkan konteks kerja agar lu bisa bilang: “Eksperimen agent ini hidup di sini. Kalau gagal, buang foldernya.”

Workflow praktis: satu task, satu worktree

Format paling gampang yang bisa lu coba:

# dari folder repo utama
cd my-app

# bikin worktree baru + branch baru
git worktree add ../my-app-ai-refactor -b experiment/ai-refactor

# masuk ke folder khusus eksperimen
cd ../my-app-ai-refactor

# jalankan install/test sesuai project
npm install
npm test

Setelah itu, arahkan AI coding agent lu ke folder ../my-app-ai-refactor, bukan ke folder utama. Kasih instruksi spesifik seperti:

Kerjakan refactor kecil di branch ini. Jangan ubah API publik. Setelah selesai, jalankan test dan tulis ringkasan file yang berubah.

Kalau hasilnya bagus, lu bisa review diff seperti biasa:

git status
git diff
git test # atau command test project lu

Kalau hasilnya kacau, lu nggak perlu panik. Commit belum ada, branch utama lu tetap aman, dan folder eksperimen bisa dibuang setelah lu cek:

cd ../my-app
git worktree remove ../my-app-ai-refactor
git branch -D experiment/ai-refactor

Kalau ada metadata worktree yang nyangkut karena folder pernah dihapus manual, Git juga punya:

git worktree prune

Use case paling masuk akal buat developer

1. Hotfix tanpa ganggu fitur yang belum selesai

Dokumentasi Git Book memberi contoh klasik: lu sedang mengerjakan user story, lalu ada hotfix mendadak. Tanpa worktree, lu harus switch branch dan memastikan working directory bersih dulu.

Dengan worktree:

git worktree add ../my-app-hotfix -b hotfix/login main
cd ../my-app-hotfix

Lu fix bug di folder hotfix, test, commit, push. Folder fitur utama tetap kebuka di editor, tanpa stash drama.

2. Review PR tanpa kehilangan konteks kerja

Kalau lu sering review PR, worktree bikin prosesnya lebih enak. Lu bisa checkout branch PR di folder terpisah, menjalankan app, dan tetap membiarkan folder utama di task awal.

git fetch origin pull/123/head:review/pr-123
git worktree add ../my-app-pr-123 review/pr-123

Ini membantu banget kalau review lu butuh running app, bukan cuma baca diff di browser.

3. Eksperimen AI agent tanpa mengacak branch utama

Ini use case favorit gua sekarang. Kalau agent mau eksplor solusi, kasih branch dan folder sendiri.

git worktree add ../my-app-agent-tests -b agent/add-tests
cd ../my-app-agent-tests

Lu bisa minta agent membuat test coverage, memperbaiki warning, atau mencoba refactor kecil. Setelah itu, lu review hasilnya sebagai pull request biasa, bukan sebagai perubahan misterius yang tiba-tiba muncul di folder utama.

Checklist sebelum kasih worktree ke AI agent

Worktree membantu, tapi bukan izin buat lepas tangan. Ini checklist yang gua pakai:

Branch name jelas: pakai nama seperti agent/add-login-tests, bukan test2.
Scope kecil: satu worktree untuk satu task yang bisa direview.
Instruksi file boundary: jelaskan folder/file mana yang boleh disentuh.
Test command jelas: minta agent menjalankan command yang relevan dan melaporkan hasilnya.
Diff review wajib: jangan merge cuma karena agent bilang “done”.
Cleanup rutin: hapus worktree yang sudah selesai biar folder project nggak jadi kuburan eksperimen.

Hal yang perlu diwaspadai

GitHub juga menyinggung beberapa catch yang realistis. Worktree bisa bikin kerja paralel lebih rapi, tapi tetap ada biaya operasional.

Dependency dobel: tiap folder bisa punya node_modules, virtualenv, build cache, atau dependency sendiri. Disk bisa cepat penuh.
Folder management: kalau lu rajin bikin worktree tapi jarang hapus, parent directory cepat berantakan.
Branch confusion: karena banyak folder terlihat mirip, lu harus disiplin cek git status dan nama branch.
Bukan security sandbox: worktree memisahkan folder kerja, tapi tidak membatasi akses proses ke file system. Kalau lu menjalankan agent atau script tidak tepercaya, lu tetap butuh sandbox beneran.

Jadi jangan overclaim. Worktree itu guardrail workflow, bukan magic shield.

Perbandingan singkat: worktree vs clone repo lagi

Pilihan	Kapan cocok	Risiko
Checkout branch biasa	Satu task linear	Stash/conflict kalau kerja belum bersih
Clone repo lagi	Isolasi total yang simpel dipahami	Boros disk, remote/config bisa beda
Git worktree	Banyak branch paralel dari repo sama	Butuh disiplin cleanup dan naming
Container/sandbox	Menjalankan kode tidak tepercaya	Setup lebih berat

Menurut gua, worktree adalah sweet spot untuk task paralel yang masih lu percaya: hotfix, review PR, dan eksperimen agent di repo sendiri. Kalau kodenya tidak tepercaya, naikkan level isolasinya.

Command ringkas yang perlu lu ingat

# lihat semua worktree
git worktree list

# bikin worktree + branch baru
git worktree add ../my-app-feature -b feature/name

# buka branch yang sudah ada di folder baru
git worktree add ../my-app-review existing-branch

# hapus worktree setelah selesai
git worktree remove ../my-app-feature

# bersihkan metadata worktree yang sudah tidak valid
git worktree prune

Takeaway buat developer yang mulai pakai AI coding agent

AI coding agent bikin eksperimen makin murah. Tapi eksperimen murah bisa berubah jadi maintenance mahal kalau semua perubahan bercampur di branch utama.

Git worktree membantu lu membangun kebiasaan sederhana: satu task, satu branch, satu folder kerja. Batasnya kelihatan. Review-nya lebih jelas. Kalau gagal, buangnya lebih mudah.

Gua nggak akan bilang semua developer wajib pakai worktree setiap hari. Tapi kalau lu sudah sering menjalankan hotfix, review PR, atau AI agent secara paralel, fitur ini layak masuk muscle memory.

FAQ singkat

Apakah git worktree menggantikan branch?

Nggak. Worktree tetap memakai branch. Bedanya, branch itu dibuka di folder kerja terpisah, jadi lu bisa mengerjakan beberapa branch tanpa checkout bolak-balik.

Apakah worktree aman buat menjalankan AI agent?

Aman dalam arti memisahkan folder kerja dan branch. Tapi worktree bukan sandbox security. Kalau agent menjalankan command berbahaya, dia tetap bisa berdampak ke sistem tergantung permission prosesnya.

Kapan sebaiknya tidak pakai worktree?

Kalau task lu cuma satu dan linear, checkout branch biasa sudah cukup. Jangan pakai worktree cuma karena kelihatan keren.

Apa kebiasaan paling penting saat pakai worktree?

Nama branch harus jelas, selalu cek git status, dan hapus worktree yang sudah selesai dengan git worktree remove.

Referensi / Bacaan Lanjut

Tags:

#Software Development #Developer Productivity #AI Coding #Git #rafli.dev