Windsurf Golang: Cascade Deep Context, Flows, Setup Lengkap

 1Traditional AI coding session context:
 2
 3Session start → [blank slate]
 4Exchange 1: "Implement X" → AI answer
 5Exchange 2: "Now add Y" → AI remember X from conversation
 6...
 7Session end → context reset, hilang semuanya
 8Minggu depan → [blank slate lagi]
 9
10Windsurf Cascade:
11
12Session start → Cascade load:
13  ✓ Files yang di-edit 3 hari lalu
14  ✓ Error yang muncul dan fix yang diterapkan
15  ✓ Keputusan arsitektur yang dibuat via chat
16  ✓ Test yang ditulis dan yang masih failing
17  ✓ Conversation history yang relevant
18
19Ini bukan "memory" dalam arti chatbot — ini adalah
20deep project context yang persist across sessions.

 1# 1. Download dari codeium.com/windsurf (macOS, Windows, Linux)
 2# 2. Create Codeium account (gratis)
 3# 3. Verify Go support — Windsurf otomatis detect go.mod, gopls di-setup otomatis
 4
 5# 4. Setup project rules
 6mkdir -p .windsurf
 7cat > .windsurf/rules.md << 'RULES'
 8# Santekno Shop — Windsurf Rules
 9
10## Project
11Go 1.22, Echo v4, pgx/v5, Redis, Kafka, Clean Architecture.
12
13## Architecture
14handler → usecase → repository → domain
15No cross-layer imports.
16
17## Error Handling
18Repository not-found: return nil, nil
19Error wrap: fmt.Errorf("package.Method: %w", err)
20HTTP errors: {"error": "UPPERCASE_CODE"}
21
22## Types
23Monetary: int64 cents ONLY. Never float64.
24IDs: UUID (github.com/google/uuid)
25
26## Testing
27testify/suite + gomock. No real DB in unit tests.
28
29## Go 1.22 ONLY
30No Go 1.23+ features.
31RULES
32
33# 5. Verify Cascade setup
34# Windsurf Settings → Cascade → Enable
35# Check: "Persist context across sessions" = ON

 1Senin: Mulai implement flash sale feature
 2  Session pagi:
 3  > "Implement FlashSale domain entity: ID, StartTime, EndTime, MaxClaims"
 4  → Windsurf implement entity
 5
 6  Session siang:
 7  > "Implement FlashSaleRepository menggunakan PostgreSQL"
 8  → Cascade tahu entity tadi pagi, implement repository yang match
 9
10Selasa pagi (lanjut):
11  > "Lanjutkan implementasi flash sale dari kemarin"
12  Cascade:
13  "Yang sudah selesai:
14   ✅ FlashSale entity  ✅ Repository interface  ✅ PostgreSQL impl
15   Yang belum:
16   ⏳ UseCase  ⏳ HTTP Handler  ⏳ Unit tests
17   Mau lanjut dari UseCase?"
18  → No re-explaining needed. Langsung productive.

 1Session debugging panjang (2-3 jam):
 2  > "go test -race failing dengan error ini: [trace]"
 3  Cascade: analyze + suggest fix
 4  > "Fix itu tidak work, coba ini: [new approach]"
 5  Cascade: iterate, tahu context dari exchange sebelumnya
 6  > "Masih fail. Coba pakai channel daripada mutex"
 7  Cascade: implement dengan channel approach
 8  [selesai, fix ditemukan]
 9
10Besok: bug baru yang related
11  > "Kemarin kita fix race condition di OrderProcessor.
12    Ada bug baru yang mirip di PaymentProcessor"
13  Cascade: tahu context debugging kemarin,
14  langsung apply pattern yang sama

 1# .windsurf/flows/go-new-feature.yaml
 2
 3name: "New Go Feature"
 4description: "Standard workflow untuk implement Go feature baru"
 5
 6variables:
 7  domain:
 8    type: string
 9    prompt: "Domain name (contoh: order, product, review):"
10  feature:
11    type: string
12    prompt: "Feature name (camelCase, contoh: cancelOrder):"
13
14steps:
15  - name: "Setup: baca spec"
16    condition: "exists('.specify/features/${feature}/spec.md')"
17    action: "read"
18    source: ".specify/features/${feature}/spec.md"
19
20  - name: "Domain entity"
21    prompt: "Implement entity changes di internal/domain/${domain}/ untuk ${feature}."
22    verify: "go build ./internal/domain/${domain}/..."
23
24  - name: "Write tests"
25    prompt: |
26      Tulis unit tests untuk ${feature} usecase menggunakan testify/suite + gomock
27      SEBELUM implement. Cover semua ACs dari spec. Tests harus fail (red state).
28    output: "internal/usecase/${domain}/${feature}_test.go"
29    verify_failing: true
30
31  - name: "Implement usecase"
32    prompt: "Implement ${feature} usecase yang membuat semua tests pass. Jangan ubah test files."
33    verify: "go test ./internal/usecase/${domain}/..."
34
35  - name: "Implement repository"
36    prompt: "Implement PostgreSQL repository untuk ${feature}."
37    verify: "go test -race ./internal/repository/..."
38
39  - name: "Implement handler"
40    prompt: "Implement HTTP handler dan update router untuk ${feature}."
41    verify: "go build ./internal/delivery/..."
42
43  - name: "Full verification"
44    run: "go test -race ./... && go vet ./..."
45    final: true

1# Run flow
2windsurf run-flow go-new-feature
3# → Windsurf prompt untuk domain dan feature name
4# → Jalankan setiap step secara berurutan
5# → Verify setiap step sebelum proceed

 1Windsurf Free Tier:
 2  ✅ Cascade context (limited history — last 7 days)
 3  ✅ Code completions (unlimited)
 4  ✅ Chat (limited: ~50 messages per hari)
 5  ✅ Flows (basic, max 5 steps per flow)
 6  ✅ Go support lengkap + project rules
 7  ❌ Extended context history (Pro only)
 8  ❌ Advanced models (Pro: Claude Sonnet, GPT-4o)
 9
10Windsurf Pro ($15/bulan):
11  ✅ Semua free tier
12  ✅ Extended context (30 days history, larger workspace)
13  ✅ Priority inference + advanced models + unlimited messages
14  ✅ Flows: unlimited steps
15
16Free tier sufficient jika:
17  - Sprint pendek (< 1 minggu per feature)
18  - Tidak butuh context dari > 7 hari lalu
19  - Daily usage < 50 AI messages
20
21Pro worth it jika:
22  - Feature development panjang (2-4 minggu)
23  - AI assistance intensif (> 50 messages/hari)

 1                      Windsurf        Cursor
 2──────────────────────────────────────────────
 3Context retention     ⭐⭐⭐⭐⭐      ⭐⭐⭐⭐
 4Multi-file editing    ⭐⭐⭐⭐        ⭐⭐⭐⭐⭐
 5Visual diff           ⭐⭐⭐⭐        ⭐⭐⭐⭐⭐
 6Go idiom quality      ⭐⭐⭐⭐        ⭐⭐⭐⭐
 7Price                 ✅ Free/$15    ❌ $20-40 flat
 8Long coding sessions  ⭐⭐⭐⭐⭐      ⭐⭐⭐⭐
 9Community             ⭐⭐⭐          ⭐⭐⭐⭐⭐
10
11Conclusion:
12  Budget constraint + long sessions → Windsurf Pro ($15)
13  Multi-file editing heavy + team → Cursor ($20-40)
14  Solo developer → Windsurf Free

 1Windsurf performance di Santekno Shop benchmark:
 2
 3Overall: 84.2/100 (rank #4)
 4
 5By scenario:
 6  S1 (Implement dari spec): 84/100 — rules.md membantu, tapi tak sekonsisten CLAUDE.md
 7  S2 (Write unit tests):    84/100 — adequate, pattern dari rules.md di-follow
 8  S3 (Refactoring):         87/100 — Cascade membantu refactoring multi-session
 9  S4 (Debug race condition):84/100 — Cascade sangat membantu debugging multi-hari
10  S5 (OpenAPI generation):  82/100 — adequate, tanpa special advantage
11
12Where Windsurf genuinely excels:
13  Long-running debugging:      ⭐⭐⭐⭐⭐
14  Multi-session feature:       ⭐⭐⭐⭐⭐
15  Budget-conscious solo dev:   ⭐⭐⭐⭐⭐
16
17Where Windsurf lags:
18  Single-session bulk editing: ⭐⭐⭐⭐ (Cursor better)
19  PR review automation:        ❌ (no built-in)
20  Go idiom precision:          ⭐⭐⭐⭐ (Claude Code better)

 1Windsurf Free (primary):
 2  - Daily coding dan completions (unlimited)
 3  - Cascade untuk context retention
 4
 5Claude Code API (pay-per-use, secondary):
 6  - Complex features yang butuh deep reasoning
 7  - SDD workflow tasks, architecture decisions
 8
 9Monthly estimate:
10  Windsurf: $0
11  Claude Code API (moderate use): $20-35/bulan
12  Total: $20-35/bulan
13
14vs single tool heavy use:
15  Claude Code only: $60-100/bulan
16  Cursor: $20-40/bulan
17
18Savings: $25-65/bulan dengan quality yang comparable

 1# .windsurf/flows/tdd-go.yaml
 2
 3name: "TDD Go Feature"
 4
 5steps:
 6  - name: "Write failing tests"
 7    prompt: |
 8      Tulis unit tests yang FAIL untuk [feature].
 9      Pattern: testify/suite. Cover: happy path, error cases, edge cases.
10    verify_failing: true
11
12  - name: "Implement to pass"
13    prompt: "Implement fungsi yang membuat semua tests pass. JANGAN ubah test files."
14    verify: "go test ./..."
15
16  - name: "Refactor"
17    prompt: "Refactor untuk readability/performance. Semua tests harus tetap pass."
18    verify: "go test -race ./..."

 1# .windsurf/flows/pre-pr-review.yaml
 2
 3name: "Pre-PR AI Review"
 4
 5steps:
 6  - name: "Error handling check"
 7    prompt: |
 8      Review file yang diubah untuk: error tak di-wrap fmt.Errorf,
 9      error di-ignore dengan _, repository error yang exposed ke atas.
10
11  - name: "Architecture check"
12    prompt: |
13      Check cross-layer imports: handler→usecase impl, usecase→repository impl,
14      domain→external packages. Output: VIOLATION atau CLEAN.
15
16  - name: "Test coverage gaps"
17    run: "go test -cover ./..."
18    prompt: "Identifikasi functions yang belum punya test."
19
20  - name: "Summary"
21    prompt: "Generate PR description dari perubahan yang ada"

1Issue: Cascade tidak ingat context dari kemarin
2
3Penyebab 1: Context expired (free tier = 7 hari)
4  → Upgrade ke Pro untuk 30-day history
5Penyebab 2: Project tidak di-index ulang
6  → Windsurf → Settings → Cascade → Force re-index
7Penyebab 3: .windsurf/rules.md tidak di-read
8  → Verify rules.md ada di root project → Reload

1Setup yang benar:
21. Pastikan gopls terinstall (Go extension)
32. Verify go.sum up to date: go mod tidy
43. Build once: go build ./...
5   → Membantu Windsurf index types dengan benar
6
7Di rules.md tambahkan:
8## Code Style Reference
9See existing code at internal/usecase/order/ for patterns.

1Common issues:
2- Go version mismatch: verify 'go' command ada di PATH
3- Flow YAML syntax error: validate dengan YAML linter
4- Step 'verify' command fails: cek command secara manual dulu

 1Scenario: Developer A (Jakarta) dan Developer B (Bali)
 2
 3Senin: Developer A implement feature setengah jalan → commit & push
 4Selasa: Developer B continue
 5  Cascade (Developer B):
 6  → Baca Git history: tau apa yang sudah diimplement
 7  → Baca commit messages: tau intent
 8
 9  Tapi Cascade Developer B TIDAK tahu:
10  → Keputusan verbal/mental Developer A
11  → Debug session yang dilakukan Developer A
12
13  Solution: Developer A buat .windsurf/handoff.md sebelum switch
14  "Implementasi CancelOrder selesai sampai usecase.
15   Outstanding: Repository test masih failing karena mock setup.
16   Approach yang gagal: [...]  Approach yang direncanakan: [...]"
17  Developer B baca handoff.md → seamless continuation

 1Approach 1: Sequential dengan verification
 2  Satu layer per waktu, bukan semua sekaligus:
 3  "Implement entity layer"   → verify build → commit
 4  "Implement usecase layer"  → verify tests → commit
 5  "Implement repository layer"→ verify tests → commit
 6
 7Approach 2: Explicit file reference
 8  "Edit HANYA file internal/usecase/order/cancel_order.go.
 9   Tambahkan method Execute yang..."
10  → Windsurf focus ke satu file, lebih akurat
11
12Approach 3: Use Flows untuk multi-step
13  Flow step-by-step dengan verification memberikan hasil
14  lebih consistent dari single "do everything" prompt.

 1Kenapa Windsurf bagus untuk beginners:
 21. Free tier = no financial commitment untuk explore
 32. UX familiar (VS Code-like), tanpa terminal workflow
 43. Completions immediate (Tab untuk accept)
 54. Chat yang guided (lebih proaktif)
 65. Cascade yang forgiving (retain context walau rules belum sempurna)
 7
 8Journey yang recommended:
 9  Month 1: Windsurf free (completions + basic chat)
10  Month 2: Explore Flows + rules.md
11  Month 3: Evaluate Pro upgrade atau add Claude Code
12  Month 4+: Decide primary tool berdasarkan real experience

 1# 1. Pastikan semua tools terinstall dan di PATH:
 2which go gopls golangci-lint mockgen staticcheck
 3
 4# 2. Setup go tools:
 5go install golang.org/x/tools/gopls@latest
 6go install go.uber.org/mock/mockgen@latest
 7go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
 8
 9# 3. Konfigurasi gopls (via settings):
10# {
11#   "gopls": {
12#     "analyses": { "shadow": true, "unusedresult": true },
13#     "staticcheck": true
14#   }
15# }
16
17# 4. Setup Makefile targets (Windsurf bisa execute):
18# make test      → go test -race ./...
19# make lint      → golangci-lint run ./...
20# make generate  → go generate ./...
21
22# Windsurf Flows bisa reference Makefile targets:
23# steps:
24#   - run: "make test"

 1Cascade menggunakan pendekatan hybrid:
 2
 31. Explicit Memory:
 4   - Key decisions via chat, error patterns + fixes, file modifications + timestamps
 52. Git Integration:
 6   - Git history sebagai context, commit messages diparsing, file diffs
 73. Semantic Index:
 8   - Codebase di-index semantic, relationship antar files, symbol definitions/usages
 94. Conversation History:
10   - Recent conversation di memory, key exchanges masa lalu di-summarize
115. Project Rules:
12   - .windsurf/rules.md di-inject di setiap query sebagai system context
13
14Berbeda dari tools yang hanya andalkan:
15  - Context window saat ini (Claude Code, Copilot inline)
16  - Workspace indexing (Cursor)
17Keunikan Cascade: kombinasi semua di atas + persistence antar sessions.

 1Solo developer:
 2  Windsurf Free + Claude Code API supplement: $0 + $300 = $300/tahun
 3  vs Cursor Pro: $240/tahun
 4  vs Claude Code only (heavy): $960/tahun
 5
 6Small team (5 devs):
 7  Windsurf Pro + Claude Code (1 senior): ($15×5×12) + $600 = $1,500/tahun
 8  vs Cursor Business: $40×5×12 = $2,400
 9  vs Copilot Business: $19×5×12 = $1,140
10
11Windsurf Pro + selective Claude Code = excellent value untuk small team.

 1Official resources:
 2  docs.codeium.com — official documentation
 3  codeium.com/windsurf/blog — updates dan best practices
 4  Discord: codeium.com/discord — active community
 5
 6Go-specific resources:
 7  #golang channel di Discord
 8  Template .windsurf/rules.md untuk Go di GitHub (search "windsurf golang rules")
 9
10Contribute:
11  Bug reports, share flows, feature requests via Discord

 1Expected dari Codeium:
 2🔜 Better monorepo support
 3🔜 Improved Go-specific completions (dedicated training data)
 4🔜 Team sharing untuk Cascade context (collaborative sessions)
 5🔜 Integration dengan GitHub Actions
 6🔜 Windsurf Extensions (custom tools API)
 7
 8Yang sudah bagus di Go:
 9✅ Basic completions  ✅ Chat assistance
10✅ Cascade single-dev context  ✅ Flows automation  ✅ Project rules

 1✅ Pilih Windsurf jika:
 2  - Solo developer atau budget sangat terbatas (free tier terbaik di market)
 3  - Feature development > 1 minggu (Cascade memberi real value)
 4  - Tim remote/async (handoff notes + Cascade membantu continuity)
 5  - Mau workflow automation via Flows
 6
 7❌ Jangan pilih Windsurf sebagai primary jika:
 8  - Butuh PR review automation (pakai Copilot)
 9  - Go idiom precision non-negotiable (pakai Claude Code)
10  - Multi-file editing sangat heavy (pakai Cursor Composer)
11  - Butuh enterprise compliance (pakai Copilot Enterprise)