Integrasi GitHub Spec Kit + Claude Code: Setup End-to-End Golang Project
Cara mengintegrasikan GitHub Spec Kit dengan Claude Code untuk project Golang. Setup lengkap end-to-end: dari inisialisasi project sampai workflow siap digunakan oleh seluruh tim.
Integrasi Spec Kit + Claude Code: Setup End-to-End Go Project
Integrasi Spec Kit + Claude Code untuk project Golang adalah langkah yang menyatukan dua tool yang selama ini kita bahas terpisah. Kita sudah install specify CLI (Artikel 02) dan memahami struktur output-nya (Artikel 03). Sekarang saatnya menyatukan semuanya: menggabungkan Spec Kit dengan Claude Code dalam satu workflow yang kohesif untuk project Santekno Shop.
Artikel ini adalah panduan “zero to working” — dari project kosong sampai workflow yang siap digunakan sehari-hari oleh seluruh tim, tanpa langkah yang tersisa mengambang.
04.1 Gambaran Arsitektur Integrasi
Sebelum menyentuh terminal, penting memahami bahwa Spec Kit dan Claude Code bukan tools yang bersaing — mereka bekerja di layer yang berbeda. Diagram berikut memisahkan tanggung jawab tiap layer agar terlihat siapa mengerjakan apa.
1┌─────────────────────────────────────────────────────────┐
2│ Layer 1: SPEC KIT (specify CLI) │
3│ Mengelola lifecycle spec: create → clarify → plan → impl│
4│ Output: file .md yang bisa di-commit │
5└────────────────────┬────────────────────────────────────┘
6 │ memberi context ke
7┌────────────────────▼────────────────────────────────────┐
8│ Layer 2: CLAUDE CODE (claude CLI) │
9│ AI yang mengeksekusi instruksi berdasarkan context │
10│ Output: file .go, test, dan dokumentasi │
11└────────────────────┬────────────────────────────────────┘
12 │ beroperasi di
13┌────────────────────▼────────────────────────────────────┐
14│ Layer 3: CODEBASE │
15│ Project Golang yang mengikuti constitution │
16└─────────────────────────────────────────────────────────┘Dengan pembagian layer ini, kamu tahu persis di mana harus mencari masalah: kalau prompt salah, itu urusan Spec Kit; kalau kode salah, itu eksekusi Claude Code. Konkretnya, ketika specify implement dijalankan, Spec Kit menjalankan empat langkah berurutan:
- Mengumpulkan context (constitution + spec + plan + tasks + kode existing)
- Membuat prompt terstruktur
- Mengirim ke Claude Code untuk eksekusi
- Menerima hasil dan menyimpan ke file yang tepat
Empat langkah ini adalah “jembatan” tak terlihat antara dokumen spec dan kode Go yang akhirnya kamu commit.
04.2 Inisialisasi Project Santekno Shop
Mari kita mulai dari project yang benar-benar baru. Rangkaian perintah berikut menyiapkan Go module, struktur direktori clean architecture, dan folder .specify/ sekaligus.
1# Buat project baru
2mkdir santekno-shop && cd santekno-shop
3git init
4
5# Inisialisasi Go module
6go mod init github.com/santekno/santekno-shop
7
8# Buat struktur direktori
9mkdir -p \
10 internal/{product,order,user}/{domain,usecase,repository,handler} \
11 cmd/server \
12 migrations \
13 api \
14 .specify/{features,history,_templates}
15
16# Buat file utama
17touch cmd/server/main.go
18touch .specify/_templates/spec.md
19touch .gitignoreSetelah blok ini selesai, kerangka project sudah berdiri lengkap dengan direktori spec — fondasi yang akan dibaca Spec Kit maupun Claude Code di langkah berikutnya.
04.3 Setup CLAUDE.md
Langkah berikutnya adalah membuat memori proyek untuk Claude Code. File CLAUDE.md berikut merangkum overview, tech stack, aturan arsitektur, dan aturan spec-first dalam satu tempat.
1cat > CLAUDE.md << 'EOF'
2# CLAUDE.md — Santekno Shop
3
4## Overview
5B2C e-commerce platform untuk Indonesia.
6
7## Tech Stack
8- Go 1.22+, Echo v4, pgx/v5, go-redis/v9
9- confluent-kafka-go v2, testify/suite, gomock
10- github.com/google/uuid
11
12## Architecture: Clean Architecture
13Layer: handler → usecase → repository → database
14Interfaces: di usecase package, bukan domain
15
16## Must Always
17- fmt.Errorf("func: %w", err)
18- context.Context sebagai parameter pertama
19- uuid.UUID untuk semua ID entity
20- Harga dalam cents (int64)
21
22## Must Never
23- ORM (GORM, Ent, dll)
24- Direct DB call dari handler
25- Business logic di handler
26
27## Spec Rule
28Setiap fitur baru WAJIB punya spec di .specify/features/[nama]/spec.md
29SEBELUM implementasi dimulai.
30EOFKarena Claude Code membaca CLAUDE.md otomatis di setiap sesi, aturan di atas menjadi context permanen — kamu tidak perlu mengulang penjelasan arsitektur setiap kali membuka session baru.
04.4 Inisialisasi specify.config.json
Jika CLAUDE.md adalah memori untuk Claude Code, maka specify.config.json adalah konfigurasi untuk Spec Kit. File berikut mendefinisikan identitas project, model AI, path penting, dan hook yang berjalan setelah implementasi.
1cat > specify.config.json << 'EOF'
2{
3 "version": "1",
4 "project": {
5 "name": "Santekno Shop",
6 "language": "go",
7 "architecture": "clean",
8 "go_module": "github.com/santekno/santekno-shop"
9 },
10 "ai": {
11 "default_model": "claude-sonnet-4-20250514",
12 "plan_model": "claude-sonnet-4-20250514",
13 "implement_model": "claude-sonnet-4-20250514"
14 },
15 "paths": {
16 "spec_dir": ".specify",
17 "source_dir": "internal",
18 "migration_dir": "migrations"
19 },
20 "hooks": {
21 "post_implement": "go build ./... && go vet ./..."
22 }
23}
24EOFPerhatikan bagian hooks.post_implement: dengan menjalankan go build dan go vet otomatis setelah setiap implementasi, Spec Kit memastikan setiap fase berakhir dalam keadaan yang bisa di-compile.
04.5 Cara specify CLI Memanggil Claude Code
Memahami apa yang terjadi “under the hood” sangat membantu saat troubleshooting. Flag --verbose membuka tirai itu dan menampilkan setiap langkah yang dilakukan Spec Kit sebelum memanggil Claude.
1# Jalankan dengan verbose untuk melihat prompt
2specify plan product-service --verbose
3
4# Output:
5# [VERBOSE] Reading constitution.md (1,245 chars)
6# [VERBOSE] Reading spec.md (2,341 chars)
7# [VERBOSE] Scanning codebase: internal/product/ (3 files, 0 chars — empty)
8# [VERBOSE] Building prompt...
9# [VERBOSE] Prompt size: 4,102 chars
10# [VERBOSE] Calling Claude API (claude-sonnet-4-20250514)...
11# [VERBOSE] Response received (15.2s, 2,891 tokens)
12# [VERBOSE] Writing .specify/features/product-service/plan.md
13# Done!Dari log ini terlihat jelas bahwa constitution dan spec dibaca dulu, baru prompt dibangun — sebuah audit trail kecil yang berguna saat output tidak sesuai harapan. Adapun prompt yang dikirim ke Claude memiliki struktur berlapis seperti berikut.
1<system prompt>
2You are an expert Go architect. Generate a technical implementation plan.
3Follow the project constitution STRICTLY.
4
5<constitution>
6[Isi constitution.md]
7
8<specification>
9[Isi spec.md]
10
11<existing_code>
12[File-file Go yang sudah ada di codebase]
13
14Generate a detailed technical implementation plan for [feature name].
15[Format instructions]Struktur berlapis inilah yang membuat output Claude konsisten: constitution selalu berada di posisi paling awal sehingga menjadi aturan yang tidak bisa diabaikan.
04.6 Claude Code Session dalam Spec Kit Workflow
Meskipun specify implement otomatis memanggil Claude, ada situasi di mana kamu ingin membuka session Claude Code manual untuk kontrol lebih. Transkrip berikut menggambarkan salah satu skenario tersebut.
1# Situasi 1: Implementasi yang perlu review lebih dalam
2# Jalankan specify implement dulu untuk generate context
3specify implement product-service --phase=1 --dry-run
4
5# Kemudian buka Claude Code session manual
6claude
7> Saya mau implementasikan Phase 1 dari product-service.
8> Berikut context yang diperlukan:
9> [Spec Kit akan auto-include context ke dalam claude session]Skenario di atas berguna ketika kamu ingin berdiskusi bolak-balik dengan AI sebelum menulis file. Untuk menyatukan keduanya secara manual, gunakan mekanisme export context berikut.
1# Export context dari Spec Kit
2specify context product-service --output=/tmp/product-context.md
3
4# Gunakan di Claude Code session
5claude --context=/tmp/product-context.md
6
7# Atau inject langsung
8cat /tmp/product-context.md | claudeDengan pola export ini, kamu mendapat keunggulan keduanya: context terstruktur dari Spec Kit plus fleksibilitas interaktif Claude Code dalam satu sesi.
04.7 Setup go.mod untuk Santekno Shop
Sebelum menulis kode fitur, dependency utama perlu ditarik dulu. Perintah go get berikut memasang seluruh library inti yang disebut di CLAUDE.md.
1# Download dependencies utama
2go get github.com/labstack/echo/v4
3go get github.com/jackc/pgx/v5
4go get github.com/redis/go-redis/v9
5go get github.com/google/uuid
6go get github.com/stretchr/testify
7go get go.uber.org/mock/gomock
8go get go.uber.org/mock/mockgen
9
10# Verifikasi go.mod
11cat go.modSetelah semua dependency ter-resolve, isi go.mod yang dihasilkan akan terlihat seperti berikut.
1module github.com/santekno/santekno-shop
2
3go 1.22
4
5require (
6 github.com/google/uuid v1.6.0
7 github.com/jackc/pgx/v5 v5.5.5
8 github.com/labstack/echo/v4 v4.12.0
9 github.com/redis/go-redis/v9 v9.5.1
10 github.com/stretchr/testify v1.9.0
11 go.uber.org/mock v0.4.0
12)Pastikan versi di go.mod selaras dengan versi yang tercantum di constitution — inkonsistensi di sini adalah sumber umum kode yang di-generate AI menjadi salah.
04.8 Verifikasi Integrasi: First Run
Sebelum menulis fitur pertama, kita perlu memastikan seluruh komponen benar-benar terhubung. Rangkaian pengecekan berikut memverifikasi CLI, API key, sampai kemampuan Spec Kit membaca go.mod.
1# Step 1: Verifikasi specify CLI
2specify --version
3# @github/spec-kit v1.x.x
4
5# Step 2: Verifikasi API key
6echo $ANTHROPIC_API_KEY
7# sk-ant-...
8
9# Step 3: Test dry-run
10specify constitution init --dry-run
11# Would create .specify/constitution.md
12
13# Step 4: Verifikasi claude code (jika sudah install)
14claude --version
15# claude v1.x.x
16
17# Step 5: Test that specify can read go.mod
18specify info
19# Project: Santekno Shop
20# Language: Go 1.22
21# Module: github.com/santekno/santekno-shop
22# Architecture: Clean Architecture
23# Features: 0 (no features yet)Jika kelima langkah menghasilkan output yang diharapkan — terutama specify info yang mengenali module dan arsitektur — berarti integrasi sudah solid dan siap dipakai untuk fitur nyata.
04.9 Git Setup untuk Spec Kit Workflow
Agar repository rapi sejak awal, tentukan file mana yang di-track dan mana yang diabaikan. Blok berikut membuat .gitignore yang menyimpan spec tapi membuang history dan cache, lalu melakukan initial commit.
1# .gitignore yang direkomendasikan
2cat > .gitignore << 'EOF'
3# Binary
4/bin/
5*.exe
6
7# Environment
8.env
9.env.local
10*.local.json
11
12# Spec Kit: keep specs, ignore history and cache
13.specify/history/
14.specify/temp/
15.specify/.cache/
16
17# Go
18*.test
19*.out
20/vendor/
21EOF
22
23# Initial commit
24git add .
25git commit -m "chore: initialize Santekno Shop with Spec Kit setup
26
27- Project structure: clean architecture
28- Spec Kit: specify.config.json configured
29- CLAUDE.md: project conventions defined
30- go.mod: dependencies initialized"Kunci di sini adalah membedakan spec (di-commit sebagai sumber kebenaran) dari .specify/history/ (artefak lokal yang tidak perlu masuk repo) — pemisahan ini menjaga repo tetap bersih untuk seluruh tim.
04.10 Branch Strategy untuk Spec Kit Workflow
Spec Kit bekerja paling baik dengan branch strategy yang memisahkan spec dari implementasi. Diagram berikut menunjukkan bagaimana branch spec/ dan feat/ hidup berdampingan.
1main (protected)
2├── develop (integration branch)
3│ ├── spec/SHOP-456-product-service ← Spec PR (spec.md, plan.md, tasks.md)
4│ ├── feat/SHOP-456-product-service ← Implementation PR
5│ └── spec/SHOP-789-cancel-order
6│ └── feat/SHOP-789-cancel-orderPola dua-branch ini membuat review spec dan review kode menjadi dua percakapan terpisah yang lebih fokus. Secara alur, workflow-nya berjalan tiga tahap:
- Buat
spec/branch → tulis spec → PR → review → merge ke develop - Buat
feat/branch → implement → PR → review → merge ke develop - Develop → main saat release
Untuk menjalankan tahap pertama secara konkret, perintah berikut membuat spec branch dan meng-commit hasil spec.
1# Membuat spec branch
2git checkout -b spec/SHOP-456-product-service develop
3
4# Setelah specify feature + clarify + plan + tasks
5git add .specify/
6git commit -m "spec(SHOP-456): add product service specification
7
8Spec: .specify/features/product-service/spec.md
9Plan: .specify/features/product-service/plan.md
10Tasks: .specify/features/product-service/tasks.md"
11
12git push origin spec/SHOP-456-product-service
13# Buat PR → review → mergeDengan meng-commit hanya folder .specify/ di spec branch, diff PR menjadi murni soal “apa yang akan dibangun” — reviewer bisa fokus ke kebenaran spec sebelum satu baris kode pun ditulis.
04.11 Pre-commit Hook untuk Spec Validation
Untuk mencegah spec yang cacat masuk ke repo, tambahkan pre-commit hook yang memvalidasi spec otomatis. Skrip berikut hanya berjalan ketika ada perubahan di .specify/features/.
1# .git/hooks/pre-commit
2cat > .git/hooks/pre-commit << 'EOF'
3#!/bin/bash
4
5# Validasi spec jika ada perubahan di .specify/
6SPEC_CHANGES=$(git diff --cached --name-only | grep "^\.specify/features/")
7
8if [ -n "$SPEC_CHANGES" ]; then
9 echo "Spec changes detected. Validating..."
10
11 # Ekstrak nama fitur dari path
12 FEATURES=$(echo "$SPEC_CHANGES" | grep -oP '\.specify/features/\K[^/]+' | sort -u)
13
14 for FEATURE in $FEATURES; do
15 if ! specify validate --feature="$FEATURE" 2>/dev/null; then
16 echo "Spec validation failed for: $FEATURE"
17 echo " Run 'specify validate --feature=$FEATURE' for details"
18 exit 1
19 fi
20 done
21
22 echo "All spec changes valid"
23fi
24EOF
25
26chmod +x .git/hooks/pre-commitHook ini menjadikan validasi spec sebagai quality gate yang berjalan tanpa perlu diingat — spec yang tidak lolos specify validate tidak akan pernah ter-commit.
04.12 VS Code Integration
Jika tim memakai VS Code, sedikit konfigurasi bisa membuat pengalaman menulis spec lebih nyaman. File settings.json berikut mengatur asosiasi file, ruler, dan word wrap khusus untuk markdown.
1// .vscode/settings.json
2{
3 "files.associations": {
4 ".specify/**/*.md": "markdown"
5 },
6 "markdown.preview.openMarkdownLinks": "inEditor",
7 "editor.rulers": [80, 120],
8 "[markdown]": {
9 "editor.wordWrap": "wordWrapColumn",
10 "editor.wordWrapColumn": 100
11 },
12 "terminal.integrated.env.linux": {
13 "ANTHROPIC_API_KEY": "${env:ANTHROPIC_API_KEY}"
14 }
15}Selain pengaturan editor, kamu bisa mendaftarkan perintah Spec Kit sebagai VS Code task agar bisa dijalankan lewat Command Palette, seperti pada konfigurasi berikut.
1// .vscode/tasks.json
2{
3 "version": "2.0.0",
4 "tasks": [
5 {
6 "label": "Spec Kit: Run Plan",
7 "type": "shell",
8 "command": "specify plan ${input:featureName}",
9 "group": "build",
10 "presentation": {
11 "reveal": "always",
12 "panel": "new"
13 }
14 },
15 {
16 "label": "Spec Kit: Run Implement Phase",
17 "type": "shell",
18 "command": "specify implement ${input:featureName} --phase=${input:phaseNumber}",
19 "group": "build"
20 }
21 ],
22 "inputs": [
23 {
24 "id": "featureName",
25 "type": "promptString",
26 "description": "Feature name (e.g., product-service)"
27 },
28 {
29 "id": "phaseNumber",
30 "type": "promptString",
31 "description": "Phase number (e.g., 1)"
32 }
33 ]
34}Dengan task ini, developer yang lebih nyaman di editor tidak perlu berpindah ke terminal — Spec Kit terasa seperti bagian native dari IDE.
04.13 Workflow Harian dengan Spec Kit + Claude Code
Setelah semua setup selesai, seperti apa hari kerja normalnya? Skrip berikut merangkum satu siklus penuh dari memilih task Jira sampai membuka implementation PR.
1# Pagi: cek Jira, pilih task
2# Task: SHOP-789 "Add product search by SKU"
3
4# 1. Buat spec branch
5git checkout -b spec/SHOP-789-search-by-sku develop
6
7# 2. Buat spec
8specify feature search-by-sku
9# Jawab 3-4 pertanyaan (5 menit)
10
11# 3. Klarifikasi
12specify clarify search-by-sku
13# Jawab pertanyaan Claude (5 menit)
14
15# 4. Generate plan
16specify plan search-by-sku
17# Otomatis (60 detik)
18
19# 5. Generate tasks
20specify tasks search-by-sku
21# Otomatis (30 detik)
22
23# 6. Review + commit spec
24git add .specify/
25git commit -m "spec(SHOP-789): add search by SKU specification"
26git push origin spec/SHOP-789-search-by-sku
27# Buat PR → review → merge
28
29# 7. Buat implementation branch
30git checkout -b feat/SHOP-789-search-by-sku develop
31
32# 8. Implementasi per phase
33specify implement search-by-sku --phase=1
34# Review output
35git add . && git commit -m "feat(product): add SKU entity type [SHOP-789]"
36
37specify implement search-by-sku --phase=2
38# Review output
39git add . && git commit -m "feat(product): add search by SKU repository [SHOP-789]"
40
41# ... lanjut per phase
42
43# 9. Final check
44go test ./... && go vet ./...
45
46# 10. Push dan buat PR
47git push origin feat/SHOP-789-search-by-skuPerhatikan ritme spec-dulu-baru-implement dan commit granular per phase — inilah yang membuat setiap PR kecil, mudah di-review, dan mudah di-rollback bila perlu.
04.14 Menghubungkan Spec Kit dengan Jira/Linear
Spec Kit bisa di-extend agar terhubung dengan tool project management. Perintah berikut menunjukkan cara membuat feature langsung dari deskripsi tiket Jira.
1# Dengan Jira CLI (jira-cli)
2# Install: npm install -g jira-cli
3
4# Buat feature dari Jira ticket
5jira view SHOP-789 | specify feature search-by-sku --from-stdin
6
7# Atau manually: copy description dari Jira ke specify feature
8specify feature search-by-sku
9# Paste Jira description saat dimintaIntegrasi tidak berhenti di pembuatan spec; kamu juga bisa memicu update status tiket otomatis lewat hooks seperti berikut.
1# Update Jira status setelah spec selesai
2specify hooks add post-specify "jira transition SHOP-789 'In Review'"
3
4# Update setelah implementasi selesai
5specify hooks add post-implement "jira transition SHOP-789 'In QA'"Dengan hooks ini, status di Jira selalu mencerminkan kondisi kode secara real-time — tidak ada lagi tiket yang lupa dipindahkan setelah pekerjaan selesai.
04.15 Monitoring Cost: Dashboard Sederhana
Karena setiap perintah Spec Kit mengonsumsi token, memantau biaya adalah kebiasaan sehat. Skrip berikut membaca log history dan merangkum jumlah perintah, token, serta estimasi biaya 30 hari terakhir.
1#!/bin/bash
2# scripts/spec-kit-cost-report.sh
3
4echo "=== Spec Kit Cost Report ==="
5echo "Project: Santekno Shop"
6echo "Period: $(date -d '-30 days' +%Y-%m-%d) to $(date +%Y-%m-%d)"
7echo ""
8
9echo "--- Commands Run ---"
10ls .specify/history/*.log 2>/dev/null | wc -l
11echo " commands total"
12
13echo ""
14echo "--- Token Usage ---"
15grep "Tokens used:" .specify/history/*.log 2>/dev/null | \
16 awk -F': ' '{
17 split($2, parts, " + ");
18 prompt += parts[1];
19 split(parts[2], c, " = ");
20 completion += c[1];
21 total += c[2]
22 } END {
23 printf "Prompt tokens: %d\n", prompt
24 printf "Completion tokens: %d\n", completion
25 printf "Total tokens: %d\n", total
26 }'
27
28echo ""
29echo "--- Cost Estimate ---"
30grep "Cost estimate:" .specify/history/*.log 2>/dev/null | \
31 awk '{gsub(/\$/, ""); sum += $NF} END {printf "Total: $%.3f\n", sum}'Laporan sederhana ini mengubah biaya AI dari angka misterius menjadi data yang bisa dipantau bulanan — dasar yang kuat untuk keputusan optimasi model.
04.16 Team Onboarding dengan Spec Kit
Salah satu keuntungan besar SDD adalah onboarding yang cepat karena semua context ada di repository. Langkah-langkah berikut adalah yang perlu dilakukan developer baru saat pertama bergabung.
1# 1. Clone repository
2git clone git@github.com:santekno/shop.git
3cd santekno-shop
4
5# 2. Install dependencies
6npm install -g @github/spec-kit
7go mod download
8
9# 3. Setup API key
10export ANTHROPIC_API_KEY="sk-ant-api03-..."
11
12# 4. Verifikasi setup
13specify info
14# Project: Santekno Shop
15# Features: 5 existing specs
16# Last updated: 2025-07-01
17
18# 5. Baca specs yang sudah ada
19cat .specify/constitution.md
20ls .specify/features/
21
22# 6. First interaction
23specify --helpKarena constitution dan seluruh spec sudah tersimpan di repo, onboarding bisa selesai dalam kurang dari 15 menit — tidak perlu sesi knowledge transfer panjang yang melelahkan.
04.17 Troubleshooting Integrasi
Integrasi yang mulus sekalipun kadang menemui masalah. Berikut tiga masalah paling umum beserta solusinya.
Masalah: specify implement tidak menghasilkan kode yang konsisten
Kemungkinan penyebab: constitution terlalu ambigu, atau kode existing yang di-scan terlalu banyak sehingga membingungkan Claude. Salah satu solusinya adalah membatasi scope scan lewat config berikut.
1// specify.config.json
2{
3 "paths": {
4 "scan_exclude": ["vendor/", "*.pb.go", "*_mock.go"]
5 }
6}Selain lewat config, kamu bisa membatasi scope langsung saat menjalankan perintah dengan flag --scope, seperti berikut.
1# Jalankan dengan scope terbatas
2specify implement product-service --phase=1 --scope=internal/product/Membatasi konteks yang dilihat Claude sering kali langsung memperbaiki konsistensi output, karena AI tidak lagi terdistraksi file yang tidak relevan.
Masalah: Plan yang dihasilkan tidak sesuai Clean Architecture
Kemungkinan penyebabnya adalah constitution yang kurang detail soal arah dependency. Solusinya: perjelas constitution dengan contoh kode yang lebih eksplisit tentang layer mana boleh meng-import layer mana.
Masalah: specify command timeout
Default timeout adalah 60 detik. Untuk fitur kompleks, naikkan lewat flag atau config seperti berikut.
1# Naikkan timeout lewat flag
2specify plan complex-feature --timeout=120Selain lewat flag, timeout bisa disetel permanen di file konfigurasi seperti berikut.
1// Atau tetapkan di config
2{
3 "ai": {
4 "timeout": 120
5 }
6}Menaikkan timeout adalah solusi cepat, tapi jika satu fitur konsisten timeout, itu sinyal bahwa fitur tersebut sebaiknya dipecah menjadi beberapa spec yang lebih kecil.
04.18 Tips & Gotchas
💡 Tip 1: Setup .specify/ sebelum menulis satu baris kode — bahkan untuk project yang sudah ada, luangkan waktu membuat constitution yang baik dulu. Constitution yang dibuat retroaktif cenderung kurang akurat.
💡 Tip 2: Gunakan --dry-run untuk preview sebelum eksekusi besar — specify implement product-service --all --dry-run menampilkan semua task yang akan dieksekusi tanpa menulis satu file pun.
💡 Tip 3: Commit setelah setiap phase, bukan setelah semua selesai — PR dengan diff 50 baris jauh lebih mudah di-review daripada 500 baris. Commit granular per phase memudahkan review dan rollback.
💡 Tip 4: Review .specify/history/ untuk cost optimization — cek perintah mana yang paling banyak mengonsumsi token. specify plan biasanya paling mahal; pertimbangkan model lebih ringan untuk specify tasks.
⚠️ Gotcha 1: Jangan jalankan specify implement --all di project besar — untuk project dengan banyak file, context window Claude bisa overflow. Selalu jalankan per phase.
⚠️ Gotcha 2: specify implement mengoverwrite file existing tanpa warning — jika file sudah ada, Spec Kit akan menimpanya. Pastikan kamu di branch yang benar sebelum menjalankan implement.
⚠️ Gotcha 3: Perubahan pada go.mod tidak otomatis di-detect — jika menambah library baru, update juga constitution agar Claude tahu library itu tersedia.
⚠️ Gotcha 4: Model yang berbeda menghasilkan output yang berbeda — jika tim memakai model berbeda, output bisa inconsistent. Standarisasi model di specify.config.json.
04.19 Checklist Setup Lengkap
Sebelum mulai menggunakan Spec Kit untuk fitur pertama, pastikan semua prasyarat sudah terpenuhi. Checklist berikut mengelompokkan verifikasi ke dalam empat kategori.
1Setup & Installation:
2[x] Node.js 18+ terinstall
3[x] specify CLI terinstall global (npm install -g @github/spec-kit)
4[x] ANTHROPIC_API_KEY di-set sebagai environment variable
5[x] specify --version menampilkan versi yang benar
6
7Project Setup:
8[x] Go module diinisialisasi (go mod init)
9[x] Directory structure sesuai clean architecture
10[x] specify.config.json di root project
11[x] .gitignore sudah exclude .specify/history/
12[x] CLAUDE.md sudah ditulis
13
14First Run Test:
15[x] specify info menampilkan project info yang benar
16[x] specify constitution init --dry-run berhasil
17[x] go build ./... berhasil
18
19Team Setup (jika tim):
20[x] Semua anggota tim sudah setup API key
21[x] specify.config.json sudah di-commit
22[x] Branch strategy sudah disepakati
23[x] PR template sudah adaJika seluruh kotak sudah tercentang, fondasi integrasi kamu solid dan siap dipakai untuk fitur nyata — tidak ada lagi kejutan setup di tengah pekerjaan.
04.20 Ringkasan
Integrasi Spec Kit + Claude Code adalah layered architecture: Spec Kit mengelola lifecycle spec dan mengotomasi prompt engineering, Claude Code melakukan eksekusi AI, dan codebase adalah output akhirnya.
Workflow harian yang direkomendasikan: spec branch → specify feature/clarify/plan/tasks → spec PR review → feat branch → specify implement per phase → review setiap phase → implementation PR.
Key integration points: specify.config.json mendefinisikan model dan hooks, CLAUDE.md dan constitution.md bekerja bersama sebagai context, dan history logs memberikan audit trail.
Critical gotcha: Selalu jalankan specify implement per phase (--phase=N), tidak pernah --all untuk project yang sudah punya kode. Review setelah setiap phase adalah bagian integral dari workflow.
Di artikel berikutnya, kita masuk ke deep dive perintah pertama yang paling fundamental: speckit.constitution — konstitusi proyek yang membentuk semua keputusan Spec Kit setelahnya.