Pair Programming dengan AI Golang: Claude Code, Cursor, Copilot

 1Model A: Developer sebagai Driver, AI sebagai Navigator
 2
 3Developer: menulis kode
 4AI: "Di sini error handling-nya kurang. Juga cek nil sebelum use order."
 5Developer: "Ah iya, terima kasih"
 6AI: "Juga, function ini sudah > 50 baris — pertimbangkan extract method"
 7
 8Model B: AI sebagai Driver, Developer sebagai Navigator
 9
10Developer: "Implement CancelOrder usecase sesuai spec ini: @specs/order/cancel-order.md"
11AI: menulis kode
12Developer: "Hm, bagian ini tidak handle concurrent cancel dengan benar"
13AI: "Kamu benar. Tambahkan SELECT FOR UPDATE? Atau optimistic locking?"
14
15Model C: Turn-based (paling efektif untuk complex features)
16
17Developer: "Kita akan implement flash sale. Saya propose approach ini: [...]"
18AI: "Approach itu solid, tapi ada concern: [...]. Consider: [alternative]"
19Developer: "OK, setuju dengan alternativenya. Mulai dari domain entity dulu."
20AI: [implements domain entity]
21Developer: [reviews, tweaks minor things]
22AI: [implements usecase]
23Developer: [reviews, approves]
24AI: [implements repository + handler]
25Developer: [final review, runs tests]

 1# Session opener yang efektif (bukan langsung ke task):
 2
 3claude
 4> Selamat pagi! Pair session kita hari ini:
 5>
 6> 1. Konteks: saya sedang implement flash sale feature
 7>    untuk Santekno Shop (lihat CLAUDE.md untuk context)
 8>
 9> 2. Target hari ini:
10>    - Selesaikan FlashSale domain entity dan usecase ClaimVoucher
11>    - Start FlashSale repository (PostgreSQL)
12>
13> 3. Current state:
14>    - Domain entity: 50% selesai (struct + basic methods ada)
15>    - Usecase: belum mulai
16>
17> 4. Blockers yang saya miliki:
18>    - Tidak yakin dengan concurrency approach untuk claim counter
19>      (Redis INCR vs PostgreSQL SELECT FOR UPDATE vs optimistic locking)
20>
21> Sebelum kita mulai code, bantu saya think through blockers di poin 4.
22> Mana approach yang paling sesuai untuk kasus ini?

 1claude
 2> Saya stuck dengan design decision. Biarkan saya jelaskan:
 3>
 4> Problem: Flash sale voucher harus atomic — tidak boleh overselling.
 5> 100 voucher, bisa 1000 request concurrent.
 6>
 7> Approach yang saya pikir:
 8> A. PostgreSQL SELECT FOR UPDATE:
 9>    Pro: simple, consistent
10>    Con: row lock, bisa jadi bottleneck
11>
12> B. Redis INCR dengan atomic counter:
13>    Pro: cepat, designed untuk ini
14>    Con: harus handle Redis down scenario
15>
16> C. Kafka-based queue:
17>    Pro: dapat handle spike
18>    Con: latency tinggi (user menunggu)
19>
20> Saya condong ke B karena high-concurrency, tapi khawatir dengan
21> Redis failure scenario. Apa yang kamu recommend?
22
23# AI tidak langsung implement — tapi membantu evaluate tradeoffs
24# Developer tetap yang decide, AI membantu think through
25
26# AI response biasanya:
27# "Untuk flash sale yang time-sensitive, Redis approach (B) memang
28#  lebih appropriate. Untuk Redis failure scenario, consider:
29#  1. Circuit breaker: jika Redis down → fallback ke PostgreSQL SELECT FOR UPDATE
30#  2. Redis Sentinel atau Cluster untuk HA
31#  3. Lua script untuk atomic check-and-increment..."

 1# Untuk developer Go yang baru belajar patterns:
 2
 3claude
 4> Saya belajar context package di Go. Implementasikan CancelOrder
 5> dengan proper context handling, DAN jelaskan setiap decision yang kamu buat.
 6>
 7> Specifically explain:
 8> - Kenapa context.WithTimeout, bukan context.WithDeadline?
 9> - Kenapa ctx harus di-pass ke pgx.Pool query, bukan context.Background()?
10> - Apa yang terjadi jika ctx di-cancel di tengah DB transaction?
11>
12> Implement sambil explain. Saya ingin understand, bukan hanya copy code.
13
14# Claude akan generate code WITH commentary:
15# "Kita gunakan context.WithTimeout karena kita tahu durasi maksimum
16#  yang acceptable (5 detik), bukan absolute deadline time..."

 1Developer: "Implement CancelOrder dengan retry logic built-in"
 2
 3AI: "Implementation dengan retry:
 4
 5func (uc *CancelOrderUseCase) Execute(...) error {
 6    for i := 0; i < 3; i++ {
 7        err := uc.tryCancel(ctx, input)
 8        if err == nil { return nil }
 9        time.Sleep(time.Duration(i) * time.Second)
10    }
11    return err
12}
13"
14
15Developer: "Saya tidak setuju dengan retry di usecase layer.
16           Retry seharusnya di infrastructure layer (HTTP client, Kafka publisher).
17           Usecase harus idempotent — caller yang decide retry."
18
19AI: "Kamu benar. Ini violates separation of concerns. Retry logic
20     seharusnya di caller (HTTP retry middleware atau Kafka consumer retry).
21     Usecase cukup return error yang specific:
22     - ErrDBTemporaryUnavailable untuk db timeout (retriable)
23     - ErrOrderAlreadyCancelled untuk business rule (not retriable)
24     Caller bisa decide berdasarkan error type."
25
26Developer: "Exactly. Update implementation tanpa retry, tapi pastikan
27           error types yang returned clear tentang retry-ability."

 1# Pattern untuk complex problem yang butuh extended thinking:
 2
 3claude
 4> Kita punya masalah serius di production:
 5> Flash sale voucher oversold 15x (1500 voucher claimed, max 100).
 6>
 7> System: Go, PostgreSQL, Redis.
 8> Race condition terjadi ketika Redis INCR dan PostgreSQL INSERT
 9> tidak atomic.
10>
11> Mari kita pair debug ini:
12>
13> 1. Dulu kita jelaskan current implementation
14>    @internal/usecase/order/cancel_order.go
15>
16> 2. Kemudian kita trace scenario yang menyebabkan oversell
17>
18> 3. Kemudian kita propose dan evaluate solutions
19>
20> 4. Kemudian kita implement solution yang terbaik
21>
22> Start dari step 1 — trace current code bersama.
23
24# AI akan:
25# - Read code
26# - Identify race window
27# - Propose fix (Lua script untuk atomic check-and-increment)
28# - Implement fix
29# - Propose test yang reproduce bug dan verify fix

 1# AI sebagai "second opinion" partner:
 2
 3claude
 4> Saya mau review PR dari teammate sebelum approve.
 5> Bantu saya think through ini:
 6>
 7> [paste PR diff atau specific section]
 8>
 9> Saya punya concern tentang:
10> - Line 45: error handling yang terasa off
11> - Line 78: ini looks like N+1 query?
12>
13> Tapi saya tidak 100% yakin. Bantu saya validate concern saya.
14> Jika concern valid, bagaimana cara menjelaskan ke teammate dengan konstruktif?

 1Pair programming dengan AI bisa sangat engaging tapi perlu time box:
 2
 3Recommended time structure:
 4
 5FOCUSED PAIR SESSION (2-3 jam):
 6  0:00-0:10  Warm up: context setting, blockers
 7  0:10-0:40  Block 1: implement feature A
 8  0:40-0:50  SHORT BREAK + review apa yang sudah dibuat
 9  0:50-1:20  Block 2: implement feature B
10  1:20-1:30  Break
11  1:30-2:00  Block 3: tests, review, cleanup
12  2:00-2:15  Session wrap: commit, document keputusan
13
14SOLO PAIR SESSION (45-60 menit):
15  0:00-0:05  Context setting
16  0:05-0:40  Focused implementation
17  0:40-0:50  Review dan commit
18  0:50-0:60  Quick debrief: apa yang learned?
19
20Warning signs bahwa session perlu di-end:
21  - Sudah > 3 jam tanpa break significant
22  - AI mulai "forget" context (responses less relevant)
23  - Developer merasa terlalu passive (AI doing all thinking)

 1Risk dari AI pair programming: developer jadi terlalu passive.
 2
 3Signs of unhealthy dynamic:
 4  ❌ Developer selalu accept AI suggestion tanpa evaluate
 5  ❌ Developer tidak bisa explain kode yang AI generate
 6  ❌ Developer tidak bisa code tanpa AI
 7  ❌ Developer tidak punya opinion tentang design decisions
 8
 9Healthy dynamic checks:
10  ✅ Developer challenge AI suggestions occasionally (lihat 15.5)
11  ✅ Developer bisa explain setiap line yang AI generate
12  ✅ Developer occasionally code tanpa AI (build muscle)
13  ✅ Developer make final architecture decisions
14
15Exercise: "Solo Friday"
16  Setiap Jumat, satu task dikerjakan tanpa AI assistance
17  Goal: maintain baseline coding skill
18  Track: apakah solo task quality degrading over time?

 1# AI pair yang sangat valuable untuk onboarding developer baru:
 2
 3# New developer (NDE) prompt:
 4claude
 5> Saya baru join tim Santekno. Ini adalah task pertama saya:
 6> [paste task dari Linear/Jira]
 7>
 8> Tolong bantu saya:
 9> 1. Understand scope task ini
10> 2. Find existing code yang similar sebagai reference
11> 3. Buat implementation plan
12> 4. Guide saya implementasi step by step
13> 5. Review implementasi saya dan berikan feedback
14>
15> Saya familiar dengan PHP/Laravel tapi baru dengan Go.
16> Kalau ada perbedaan Go vs PHP yang penting, tolong explain.

 1# Ketika pair session perlu dilanjutkan besok atau oleh orang lain:
 2
 3claude
 4> Sebelum kita selesai hari ini, bantu saya dokumentasikan:
 5>
 6> 1. State saat ini: apa yang sudah selesai, apa yang belum
 7> 2. Keputusan yang dibuat dan kenapa
 8> 3. Unresolved questions yang masih outstanding
 9> 4. Next steps yang jelas untuk dilanjutkan besok
10> 5. Code yang perlu perhatian khusus dan kenapa
11>
12> Format sebagai HANDOFF.md yang bisa saya commit ke repo
13
14# Claude generate HANDOFF.md
15# Commit ke feature branch
16# Besok (atau orang lain): baca HANDOFF.md → immediate context

 1Anti-pattern 1: Passive passenger
 2  Developer hanya accept semua AI output tanpa review
 3  → Kode yang tidak dipahami masuk ke production
 4  Fix: developer harus bisa explain setiap line
 5
 6Anti-pattern 2: Context overload
 7  Developer paste seluruh codebase + semua docs ke satu session
 8  → AI overwhelmed, response quality turun
 9  Fix: targeted context sesuai task
10
11Anti-pattern 3: No commitment to output
12  AI generate 200 baris kode → developer langsung push
13  → No review, no testing
14  Fix: selalu go build + go test sebelum commit
15
16Anti-pattern 4: Endless discussion (analysis paralysis)
17  50+ exchange tentang "approach terbaik" tanpa pernah implement
18  Fix: time-box discussion phase (max 10 menit), kemudian implement dan evaluate
19
20Anti-pattern 5: Mengabaikan AI suggestion karena ego
21  "Saya lebih tahu daripada AI"
22  → Miss valuable insights
23  Fix: evaluate suggestion dengan objektif, bukan ego
24
25Anti-pattern 6: Pakai AI untuk semua task
26  Bahkan untuk task yang 2 menit bisa diselesaikan tanpa AI
27  → Context switch overhead > actual benefit
28  Fix: AI untuk task > 15 menit, manual untuk yang lebih simple

 1Ranked oleh kualitas sebagai "pair partner":
 2
 31. Claude Code (94/100 overall, best for pair)
 4   - Reasoning yang paling mendalam
 5   - Bisa explain kenapa, tidak hanya how
 6   - Long context retention
 7   - Can run verification commands
 8   Best for: complex problem solving, learning sessions
 9
102. Cursor (87.8/100)
11   - Visual: developer lihat code berubah secara langsung
12   - Good for: bulk implementation pairs
13   - Composer sebagai "AI yang implement, developer yang approve"
14   Best for: multi-file implementation sessions
15
163. GitHub Copilot (80.2/100)
17   - Inline suggestion sebagai real-time pair
18   - @workspace untuk contextual questions
19   - Smooth untuk coding flow tanpa context switch
20   Best for: daily coding flow, tidak perlu deep dialogue
21
224. Windsurf (84.2/100)
23   - Cascade untuk long sessions (AI ingat context)
24   - Good untuk debugging sessions yang berlangsung beberapa hari
25   Best for: extended debugging pair sessions
26
275. AWS Kiro (88/100)
28   - Spec-driven pair: develop spec together, implement together
29   Best for: new feature planning + implementation
30
316. Gemini (78.8/100)
32   - Good untuk large codebase exploration
33   Best for: codebase discovery sessions

 1Bagaimana mengukur pair programming dengan AI efektif?
 2
 3Kuantitatif:
 4  - Task completion time (solo vs pair AI)
 5  - Code quality score (AI review setelah session)
 6  - Bug rate post-merge dari pair sessions vs solo
 7
 8Kualitatif (survey mingguan):
 9  "Seberapa confident kamu dengan kode yang dihasilkan sesi pair?"
10  "Apakah sesi pair membantu understanding kamu tentang problem?"
11  "Seberapa efektif komunikasi dengan AI dalam sesi ini?"
12
13Healthy ratio:
14  60-70% tasks dengan AI pair
15  30-40% tasks solo (maintain coding muscle)

 1# AI sebagai architecture partner:
 2
 3claude
 4> Kita butuh design decision untuk flash sale ordering system.
 5> Mari kita explore bersama, bukan langsung implement.
 6>
 7> Problem: 100,000 concurrent user saat flash sale.
 8> Kita perlu system yang:
 9> 1. Fair: siapa cepat dia dapat
10> 2. Reliable: tidak oversell
11> 3. Fast: response < 500ms
12>
13> Saya propose dua approach:
14> Approach A: [describe]
15> Approach B: [describe]
16>
17> Tolong:
18> 1. Identify strengths dan weaknesses masing-masing
19> 2. Identify failure scenarios yang saya mungkin miss
20> 3. Propose trade-off matrix
21> 4. Recommend approach dengan justifikasi
22> 5. Jika ada approach C yang better, propose itu
23>
24> Kita tidak implement dulu — hanya think through.

 1# Situasi: production down, perlu hotfix CEPAT
 2
 3# Pressure situation membutuhkan pair yang reliable:
 4claude
 5> URGENT: production down. Error ini muncul di log:
 6> [paste error + stack trace]
 7>
 8> Ini adalah critical path: order creation gagal untuk semua user.
 9> Saya perlu:
10> 1. Immediate diagnosis: apa penyebab error ini?
11> 2. Quick fix: minimum change yang aman untuk stop the bleeding
12> 3. Root cause: kenapa ini bisa terjadi setelah deploy tadi?
13> 4. Proper fix: apa yang perlu di-fix dengan benar di sprint berikutnya?
14>
15> Prioritas sekarang: #1 dan #2 (immediate fix dulu)

 1# Senior developer sebagai navigator, AI sebagai "junior yang belajar cepat":
 2
 3# Senior: "Kita implement flash sale. Sebelum kode, jelaskan ke saya
 4#           approach yang kamu propose dan kenapa."
 5# AI: [explain approach dengan tradeoffs]
 6# Senior: "Good point tentang Redis. Tapi kamu tidak mention
 7#           circuit breaker. Kenapa?"
 8# AI: [acknowledge dan add circuit breaker ke proposal]
 9# Senior: "OK, implement sesuai approach yang sudah kita agree."
10# AI: [implements]
11# Senior: [reviews, catches a subtle bug]
12# AI: [acknowledges dan fixes]
13
14# Yang terjadi di sini:
15# Senior transfer expertise via dialogue (bukan hanya code review)
16# AI "belajar" konvensi tim dari exchanges
17# Output code lebih baik dari "AI langsung implement tanpa dialogue"

 1After every significant pair session (> 1 jam), spend 5 menit reflect:
 2
 3What worked:
 4  ✓ AI yang langsung understand requirement tanpa banyak clarification
 5  ✓ AI yang catch error sebelum saya run test
 6  ✓ AI yang propose alternative yang tidak saya pikirkan
 7  ✓ Sesi yang productive dari awal sampai akhir
 8
 9What didn't work:
10  ✗ AI yang generate code dengan pattern yang salah (miss CLAUDE.md)
11  ✗ Context yang hilang di tengah sesi panjang
12  ✗ Saya yang terlalu passive (tidak challenge AI)
13  ✗ Task yang terlalu besar untuk satu session
14
15Action items:
16  → Update CLAUDE.md untuk pattern yang sering missed
17  → Break task besar ke sessions yang lebih kecil
18  → Commit lebih sering sebagai checkpoints
19  → Challenge AI setidaknya satu kali per session (buat habit)

 1# Pair bukan hanya untuk writing — juga untuk reading existing code:
 2
 3claude
 4> Saya perlu understand kode ini sebelum modify:
 5> [paste complex function atau module]
 6>
 7> Bantu saya understand:
 8> 1. Apa yang function ini lakukan (high level, satu kalimat)
 9> 2. Apa yang data flow-nya? (input → processing → output)
10> 3. Apa edge cases yang perlu diperhatikan saat modify?
11> 4. Apa dependencies yang perlu diketahui?
12> 5. Apa yang bisa break jika saya modify X?

 1# AI PAIR SESSION TEMPLATE
 2
 3## Date: [date]
 4## Developer: [name]
 5## Session Goal: [one sentence]
 6## Time budget: [X hours]
 7
 8## Context (paste ke AI di awal session):
 9> Sesi pair kita hari ini. Context:
10> - Project: Santekno Shop (lihat CLAUDE.md)
11> - Task: [task description]
12> - Status saat ini: [apa yang sudah ada]
13> - Blockers: [apa yang perlu dipikirkan dulu]
14> - Target selesai: [apa yang harus ada di akhir sesi]
15>
16> Mulai dengan bantu saya think through [blocker] sebelum implement.
17
18## Session Log (isi selama sesi):
19- [timestamp]: Decision: [apa yang diputuskan]
20- [timestamp]: Concern raised: [oleh siapa, tentang apa]
21- [timestamp]: Pivot: [kenapa, ke apa]
22
23## End of Session:
24Apa yang selesai: [list]
25Apa yang pending: [list]
26HANDOFF: [bisa dilanjutkan oleh siapa saja yang baca ini]

 1Sebelum memulai:
 2□ CLAUDE.md sudah di-read oleh AI (atau explicitly reference di prompt)
 3□ Task/spec jelas dan tersedia
 4□ Git branch dibuat: git checkout -b feature/X
 5□ Test environment siap
 6
 7Selama session:
 8□ Commit setiap 30-45 menit (checkpoint)
 9□ Challenge AI setidaknya satu kali (healthy disagreement)
10□ run go test setelah setiap significant change
11□ Take short break setiap 1 jam
12
13Selesai session:
14□ All tests pass: go test -race ./...
15□ Code reviewed (AI self-review)
16□ Committed dengan meaningful messages
17□ HANDOFF.md dibuat jika dilanjutkan
18□ Document key decisions (ADR jika significant)

 1Untuk tim yang mau adopt AI pair sebagai culture:
 2
 3Week 1: Individual exploration
 4  Setiap developer coba AI pair untuk 1 task
 5  No pressure, no judgment
 6  Share experience di weekly retro
 7
 8Week 2-3: Pair with observation
 9  2 developers pair (satu coding, satu observe)
10  Observe: bagaimana mereka interact dengan AI?
11  Share learnings
12
13Week 4: Define team norms
14  "Kita agree bahwa AI pair digunakan untuk X situasi"
15  "Kita tidak agree bahwa AI pair untuk Y situasi"
16  Document di team handbook
17
18Month 2+: Measure dan iterate
19  Track metrics (15.14)
20  Adjust norms berdasarkan data
21  Update CLAUDE.md berdasarkan patterns yang emerged

 1AI pair programming sangat valuable untuk remote tim:
 2
 3Challenge remote pair programming tradisional:
 4  - Scheduling timezone yang berbeda
 5  - Connection quality yang buruk saat screen share
 6  - Sense of presence yang kurang
 7  - Sulit untuk "tap on shoulder" minta help
 8
 9AI pair sebagai complement:
10  Developer solo + AI pair = productive tanpa scheduling overhead
11
12  Tapi masih butuh occasional human pair:
13  - Weekly human pair session (bukan daily)
14  - Untuk architecture decisions yang major
15  - Untuk onboarding dan knowledge transfer
16  - Untuk complex bugs yang butuh domain expertise
17
18Rekomendasi untuk remote tim di Indonesia:
19  Senin Pagi: Team sync (30 menit) — task distribution, blockers
20  Senin-Kamis: Individual work + AI pair (majority)
21  Jumat Pagi: Human pair sessions (optional, voluntary)
22  Jumat Sore: Retro + knowledge sharing dari AI pair sessions

 1Exercise 1: The 20-Question Pair (Day 1 onboarding)
 2  New developer: 20 pertanyaan tentang codebase ke AI
 3  AI menjawab berdasarkan actual code
 4  Tujuan: understand codebase structure dalam 2 jam
 5
 6Exercise 2: The Architecture Debate
 7  Developer propose design, AI critique, developer defend atau change
 8  At least 3 back-and-forth exchanges sebelum implement
 9  Track: apakah design berubah dari awal ke akhir?
10
11Exercise 3: The Blindfold Review
12  AI implement sesuatu, developer review TANPA AI
13  Hanya setelah review done: AI explain kenapa implement begitu
14  Tujuan: maintain independent code reading skill
15
16Exercise 4: The Handoff Challenge
17  Developer A pair dengan AI sampai 50% selesai
18  Developer B baca HANDOFF.md dan lanjutkan dengan AI
19  Tujuan: validate handoff quality dan async continuity

 1Books yang relevant:
 2  "The Pragmatic Programmer" — pair programming principles
 3  "Clean Code" — code quality yang AI pair harus enforce
 4  "Team Topologies" — bagaimana teams interact, termasuk AI-assisted
 5
 6Articles:
 7  Ardan Labs Blog — Go best practices yang AI harus follow
 8  Iman Tumorang's articles — software architecture dari perspective Indonesia
 9
10Communities:
11  Gophers Indonesia (Discord) — komunitas Go developer Indonesia
12  r/golang — global Go community
13  Claude Discord — Claude Code users sharing tips
14
15Practice:
16  Setiap Senin pagi: 30 menit AI pair session dengan satu task baru
17  Setiap Jumat sore: reflect dan update CLAUDE.md berdasarkan learning
18  Monthly: retrospective tentang AI pair effectiveness di tim