Cara Kerja AI Coding Agent Golang: Claude Code, Cursor, Copilot Explained

 1┌─────────────────────────────────────────────────────────────┐
 2│                    AI Coding Agent                           │
 3├────────────────────┬────────────────────────────────────────┤
 4│  1. LLM Core       │  Large Language Model — "otak" agent    │
 5│                    │  Claude, GPT-4o, Gemini, dll            │
 6│                    │  Bertanggung jawab atas reasoning       │
 7│                    │  dan generation                         │
 8├────────────────────┼────────────────────────────────────────┤
 9│  2. Context Engine │  Apa yang di-feed ke LLM sebelum kamu   │
10│                    │  mengetik satu karakter pun             │
11│                    │  CLAUDE.md, file-file relevant,         │
12│                    │  conversation history, RAG results      │
13├────────────────────┼────────────────────────────────────────┤
14│  3. Tool Executor  │  Mekanisme agar LLM bisa take action    │
15│                    │  bukan hanya generate text              │
16│                    │  read_file, write_file, run_command,    │
17│                    │  search_codebase, browse_web            │
18└────────────────────┴────────────────────────────────────────┘

 1[SYSTEM PROMPT — built by the tool, invisible to you]:
 2"You are an expert Go developer working on a production e-commerce system.
 3
 4[Content dari CLAUDE.md]:
 5  Architecture: handler → usecase → repository → domain
 6  Error handling: fmt.Errorf("pkg.Method: %w", err)
 7  Monetary: int64 cents, never float64
 8  Go 1.22, pgx/v5, echo/v4
 9  ...
10
11[Auto-injected context — files the tool thinks are relevant]:
12  internal/delivery/http/handler/order_handler.go:
13    [full content of existing order handler]
14
15  internal/domain/order/entity.go:
16    [full content of domain entity]
17
18  internal/usecase/order/create_order.go:
19    [full content of create order as pattern reference]
20
21  go.mod:
22    [module name and dependency versions]
23
24[Optional context — varies by tool]:
25  Recent git diff (Cursor)
26  Open spec files (Claude Code)
27  Recent conversation history"
28
29[USER MESSAGE]:
30"Implement CancelOrder handler"

 1Estimasi ukuran dalam tokens:
 2
 3Satu file Go medium (300 baris):          ~3,000 tokens
 4Satu Go package (10 files):              ~30,000 tokens
 5CLAUDE.md yang comprehensive:             ~2,000 tokens
 6Santekno Shop full codebase (~10K baris): ~80,000-120,000 tokens
 7
 8Context windows:
 9──────────────────────────────────────────────────────
10Claude Code:  200,000 tokens  → fit hampir seluruh medium codebase
11Cursor:       ~100,000 tokens → smart selection diperlukan
12Copilot:      ~64,000 tokens  → hanya beberapa package utama
13Gemini:     1,000,000 tokens  → fit hampir semua codebase enterprise
14AWS Kiro:    ~200,000 tokens  → comparable to Claude Code
15Windsurf:    ~100,000 tokens  → comparable to Cursor

 1Kalimat ini: return fmt.Errorf("pkg.Method: %w", err)
 2Di-tokenize menjadi sesuatu seperti:
 3["return", " fmt", ".Errorf", "(\"", "pkg", ".", "Method", ":", " %", "w", "\", err", ")"]
 4~13 tokens untuk 1 baris kode
 5
 6Implikasi untuk cost calculation:
 7  Claude Sonnet: ~$3/1M input tokens, ~$15/1M output tokens
 8
 9Implement CancelOrder feature (estimate):
10  Input:  system prompt (~5K) + CLAUDE.md (~2K) + relevant code (~10K) = 17K tokens
11  Output: generated code (~3K) + explanation (~500) = 3.5K tokens
12  Cost:   17K × $3/1M + 3.5K × $15/1M ≈ $0.10 per feature

 1Sequence diagram untuk "Implement CancelOrder dan run test-nya":
 2
 3User: "Implement CancelOrder dan run test-nya"
 4    │
 5    ▼
 6LLM internal reasoning:
 7  "Saya perlu baca existing code dulu untuk memahami patterns."
 8    │
 9    ▼
10LLM output: {
11    "type": "tool_use",
12    "name": "read_file",
13    "input": {"path": "internal/usecase/order/create_order.go"}
14}
15    │
16    ▼
17Tool Executor: baca file, return konten ke LLM
18    │
19    ▼
20LLM: "Baik, saya lihat pattern-nya. Sekarang saya akan implement."
21  {
22    "type": "tool_use",
23    "name": "write_file",
24    "input": {
25      "path": "internal/usecase/order/cancel_order.go",
26      "content": "package order\n\nimport ..."
27    }
28  }
29    │
30    ▼
31Tool Executor: tulis file
32    │
33    ▼
34LLM: "Sekarang jalankan test untuk verifikasi."
35  {
36    "type": "tool_use",
37    "name": "run_command",
38    "input": {"command": "go test ./internal/usecase/order/..."}
39  }
40    │
41    ▼
42Tool Executor: jalankan test, return output ke LLM
43    │
44    ▼
45LLM: "Test pass. Implementation complete."
46    │
47    ▼
48User melihat: hasil final

1MANUAL ◄─────────────────────────────────────────────► AUTONOMOUS
2
3Copilot         Cursor          Claude Code      AWS Kiro
4(suggestions,   (Composer:      (Plan mode:      (spec-driven,
5 accept/reject  show diff first, reason then     auto-execute
6 per line)      approve to      execute,         dengan hooks)
7                apply)          confirm per
8                                major step)

 1Task sederhana — autonomous OK:
 2  "Add context timeout ke semua repo methods"
 3  → AI bisa langsung edit dan verify compile
 4
 5Task dengan business logic — semi-autonomous:
 6  "Implement cancel order"
 7  → AI plan dulu, show approach, user approve, baru execute
 8
 9Task critical/risky — manual preferred:
10  "Refactor payment service"
11  → Review setiap perubahan, jangan auto-apply apapun
12
13Rules of thumb:
14  Reversible task (bisa git reset) → higher autonomy OK
15  Irreversible atau high-impact     → lower autonomy, more verification

 1RAG Pipeline untuk AI Coding:
 2
 3Step 1: INDEXING (dilakukan di background, sekali atau periodic)
 4  Seluruh codebase di-parse dan di-chunk menjadi potongan-potongan kecil
 5  Setiap chunk di-convert ke vector embedding (representasi numerik)
 6  Vectors disimpan di vector database lokal
 7
 8Step 2: RETRIEVAL (setiap kali ada query)
 9  Query kamu di-convert ke vector
10  Vector database mencari chunks yang paling similar
11  Return top-K chunks yang paling relevan
12
13Step 3: AUGMENTATION (inject ke context)
14  Chunks yang retrieved di-inject ke context LLM
15  Bersama CLAUDE.md, conversation history, dan file yang sedang dibuka
16
17Step 4: GENERATION (LLM process)
18  LLM generate response berdasarkan augmented context

 1Query: "Implement error handling di CancelOrder yang konsisten dengan codebase"
 2
 3RAG retrieves:
 4  → internal/usecase/order/create_order.go (similarity: high)
 5  → internal/domain/order/errors.go (similarity: very high)
 6  → internal/delivery/http/handler/order_handler.go (similarity: high)
 7  → internal/repository/postgres/order_repository.go (similarity: medium)
 8
 9NOT retrieved (correctly):
10  → internal/usecase/product/... (different domain)
11  → internal/kafka/... (different concern)

 1// Standard library — sangat well-represented:
 2import (
 3    "context"
 4    "fmt"
 5    "sync"
 6    "time"
 7)
 8
 9// Popular packages — well-represented:
10"github.com/labstack/echo/v4"
11"github.com/jackc/pgx/v5"
12"github.com/google/uuid"
13
14// Go patterns yang umum — tahu dengan baik:
15// - Interface definition dan implementation
16// - Error wrapping dengan fmt.Errorf
17// - Context propagation
18// - Struct embedding
19// - Goroutine lifecycle

 1// Package internal kamu — tidak ada di training data:
 2"github.com/santekno/santekno-shop/internal/domain/order"
 3
 4// Konvensi tim kamu — tidak ada di training data:
 5// "Untuk not-found dari repository: return nil, nil"
 6// "Error code HTTP: UPPERCASE_SNAKE_CASE"
 7
 8// Go version terbaru — tergantung training cutoff:
 9// range-over-func (Go 1.22), iter.Seq (Go 1.23)
10// "Proyek ini Go 1.22 — jangan pakai fitur 1.23+"

 1Sedang generate cancel_order.go:
 2
 3Token 1: "package"
 4Token 2: " order"
 5Token 3: "\n\nimport"
 6Token 4: " (\n"
 7Token 5: "\t\"context\""
 8...
 9
10Setiap token dipilih berdasarkan probability distribution.
11Contoh untuk token berikutnya setelah "if err != nil {":
12  → "\n\t\treturn" : 45% probability (error return)
13  → "\n\t\tlog"    : 20% probability (logging)
14  → "\n\t\tpanic"  : 5% probability (panic — unusual di Go)
15  → lainnya        : 30%
16
17LLM memilih "return" karena highest probability
18DAN karena CLAUDE.md bilang "always use explicit error handling, never panic"

1Temperature mengontrol "kreativitas" vs "determinism":
2
3Low temperature (0.1):   Output sangat deterministic, konsisten
4                         Ideal untuk: kode production, test generation
5
6High temperature (0.8):  Output lebih varied, kreatif
7                         Ideal untuk: brainstorming, documentation
8
9Default kebanyakan tools: 0.2-0.4 untuk coding tasks

1// AI generate dengan confidence tinggi:
2import "github.com/pgx/v5/pgxutil"  // ← TIDAK ADA package ini
3
4// Yang benar:
5import "github.com/jackc/pgx/v5"    // ← exact module path
6
7// Pencegahan: tuliskan exact import paths di CLAUDE.md
8// Recovery: selalu run `go build` setelah AI generation

 1Percakapan yang panjang (>100 exchanges) bisa menyebabkan
 2bagian awal context (termasuk CLAUDE.md) "keluar" dari window.
 3
 4Symptoms:
 5  - AI generate float64 untuk monetary (padahal CLAUDE.md bilang int64)
 6  - Error handling tidak di-wrap
 7  - Package path yang salah
 8
 9Recovery:
10  - Mulai session baru
11  - Re-state rules yang paling kritis: "Remember: never float64 for money"
12  - Atau: mulai dengan "Read CLAUDE.md and confirm top 3 rules"

 1// Prompt: "Implement error handling"
 2// AI interpret: generic error handling tanpa context
 3
 4// Better prompt:
 5// "Implement error handling sesuai CLAUDE.md:
 6//  - Repository not-found: return nil, nil
 7//  - Error wrap: fmt.Errorf('pkg.Method: %w', err)
 8//  - Domain errors dari internal/domain/errors/"
 9
10// Semakin specific prompt → semakin specific output

1// Jika mayoritas training data menggunakan database/sql:
2// AI mungkin generate database/sql code untuk Go
3// Padahal kamu pakai pgx/v5
4
5// Pencegahan di CLAUDE.md:
6// "NEVER use database/sql. ALWAYS use github.com/jackc/pgx/v5"

 1Tanpa caching (setiap request bayar penuh):
 2  CLAUDE.md:                2,000 tokens × $3/1M    = $0.006
 3  Project context:         10,000 tokens × $3/1M    = $0.030
 4  User query:                 100 tokens × $3/1M    = $0.0003
 5  Total input: ~$0.036
 6
 7Dengan prompt caching (claude-sonnet-4):
 8  CLAUDE.md (cached):       2,000 tokens × $0.30/1M  = $0.0006  (10x cheaper)
 9  Project context (cached): 10,000 tokens × $0.30/1M = $0.003
10  User query (not cached):    100 tokens × $3/1M     = $0.0003
11  Total input: ~$0.004  (90% cheaper!)

 1Total latency =
 2  Client-side preparation (build context, RAG retrieval): 50-500ms
 3  + Network round-trip ke API server:                     50-200ms
 4  + Time to First Token (TTFT):                           200-800ms
 5  + Generation speed:                                     50-100 tokens/second
 6  + Post-processing (format, apply):                      10-100ms
 7
 8Untuk response 500 tokens:
 9  ~300ms + ~100ms + ~400ms + 5,000ms + ~50ms ≈ 5.9 detik
10
11Untuk response 100 tokens (simple answer):
12  ~300ms + ~100ms + ~400ms + 1,000ms + ~50ms ≈ 1.85 detik

 1# Batch related questions
 2# SLOWER:
 3> Implement function X
 4# [wait ~5s]
 5> Now add error handling
 6# [wait ~5s]
 7# Total: 10s
 8
 9# FASTER:
10> Implement function X with proper error handling, context timeout, and unit test
11# [wait ~8s]
12# Total: 8s, dan output lebih comprehensive

 1Terminal / Shell
 2     │
 3     ▼
 4Claude Code CLI (Node.js process)
 5     │
 6     ├── Load CLAUDE.md dari project root dan parent dirs
 7     ├── Build context dari git status, recent files
 8     ├── Implement tool set: read, write, execute, search
 9     │
10     ▼
11Anthropic API (claude-sonnet-4)
12     │
13     ▼
14Response stream → Tool execution loop → Next LLM call → ...

 1Cursor IDE (Electron, VSCode-based)
 2     │
 3     ├── Active file + surrounding context (IDE-aware)
 4     ├── .cursorrules di-load dari project root
 5     ├── RAG index dari workspace (vector embeddings)
 6     ├── Recent conversation history
 7     │
 8     ▼
 9LLM Provider API (pluggable: Claude/GPT-4o/Cursor-1)
10     │
11     ▼
12Diff generator → Visual review → Apply to files

 1VS Code Extension / JetBrains Plugin
 2     │
 3     ├── Active file context (small window)
 4     ├── .github/copilot-instructions.md
 5     ├── Nearby files (heuristic selection)
 6     │
 7     ▼
 8GitHub Proxy → OpenAI/Anthropic API
 9     │
10     ▼
11Inline suggestion atau Chat response
12
13+ PR Review Pipeline:
14  GitHub PR webhook → Copilot analysis → PR comment

 1SHORT-TERM MEMORY:
 2  Conversation history dalam satu session
 3  → Hilang ketika session ditutup
 4  → Semua tools punya ini
 5
 6MEDIUM-TERM MEMORY:
 7  Project context files (CLAUDE.md, .cursorrules)
 8  → Persist across sessions via files
 9  → Developer yang maintain ini secara eksplisit
10
11LONG-TERM MEMORY:
12  Windsurf Cascade: semantic session memory lintas sessions
13  → Lebih dari sekadar file — ingat "apa yang dikerjakan"
14  → Unik di 2026, tools lain belum ada yang comparable
15
16EXTERNAL MEMORY:
17  RAG indexes (Cursor, Copilot Workspace)
18  → Vector database dari codebase
19  → Retrieved on-demand berdasarkan relevance

 1// WRONG — goroutine leak
 2go func() {
 3    result := heavyOperation()
 4    resultCh <- result  // Jika tidak ada yang read, goroutine bocor selamanya
 5}()
 6
 7// CORRECT — dengan context dan proper lifecycle
 8func (w *Worker) processWithTimeout(ctx context.Context, job Job) error {
 9    doneCh := make(chan error, 1)
10
11    go func() {
12        doneCh <- w.process(ctx, job)
13    }()
14
15    select {
16    case err := <-doneCh:
17        return err
18    case <-ctx.Done():
19        return fmt.Errorf("worker.processWithTimeout: context cancelled: %w", ctx.Err())
20    }
21}

 1## Goroutine Safety
 2- Every goroutine must have a clear termination condition
 3- Use context.Context for cancellation propagation
 4- Buffered channels for "fire and forget" where appropriate
 5- sync.WaitGroup for tracking goroutine completion
 6- Never share memory without mutex or channel
 7
 8## Race Condition Prevention
 9- Run: go test -race for all concurrent code
10- Prefer channel communication over shared state
11- Use sync/atomic for simple counters
12- Prefer sync.RWMutex over sync.Mutex for read-heavy workloads

 1Claude Code:
 2  → Apply changes langsung (atau tanya konfirmasi untuk perubahan besar)
 3  → Bisa run go build otomatis jika dikonfigurasi
 4  → Tidak otomatis format dengan go fmt (user responsibility)
 5
 6Cursor:
 7  → Generate unified diff
 8  → Tampilkan visual review interface
 9  → Apply hanya setelah approval
10
11GitHub Copilot:
12  → Inline: instant apply (seperti autocomplete)
13  → Chat: show code block, manual apply
14  → PR Review: comment, tidak auto-apply
15
16Windsurf:
17  → Similar ke Cursor: show changes, approve to apply
18
19Best practice setelah ANY AI generation untuk Go:
20  go build ./...      # catch compile errors
21  go vet ./...        # catch logical issues
22  go test -race ./... # catch race conditions
23  golangci-lint run   # catch style issues

 1# Step 1: Biarkan compiler berbicara
 2go build ./...
 3# Compiler error biasanya sangat specific dan actionable
 4
 5# Step 2: Feed error kembali ke AI
 6claude
 7> go build error:
 8> ./internal/usecase/order/cancel_order.go:45:15:
 9>   undefined: domain.ErrOrderNotFound
10>
11> domain package ada di internal/domain/order/errors.go.
12> Fix this.
13
14# Step 3: Untuk logical error (compile tapi wrong behavior)
15go test ./internal/usecase/order/... -v
16
17# Step 4: Untuk race condition
18go test -race ./...
19
20# Step 5: Jika AI stuck (generate same wrong code berkali-kali)
21> Forget previous implementation. Start from scratch.
22> The requirements are:
23> [re-state requirements dengan lebih clear]

 1# INEFFICIENT: 4 separate requests = 4x overhead
 2> Implement Execute method
 3> Add error handling to Execute
 4> Write test for Execute
 5> Add godoc comment
 6
 7# EFFICIENT: 1 request
 8> Implement Execute method with:
 9> - Proper error handling (fmt.Errorf wrap)
10> - Unit test (testify/suite + gomock)
11> - Godoc comment

1# INEFFICIENT: Explain pattern from scratch
2> Error handling harus wrap dengan fmt.Errorf dan "%w"
3> dan return domain error untuk not-found...
4
5# EFFICIENT: Reference existing code
6> Implement CancelOrder following the EXACT same pattern
7> as CreateOrder at internal/usecase/order/create_order.go

1# AMBIGUOUS: AI mungkin touch terlalu banyak file
2> Implement cancel order feature
3
4# PRECISE: Scope yang jelas
5> Implement internal/usecase/order/cancel_order.go
6> following spec.md ACs 1-6.
7> Only create/modify this one file.