Douze modèles pour écrire du Go idiomatique avec Claude Code
Douze modèles Claude Code pour un Go idiomatique : prompts axés sur les interfaces, boucles pilotées par des tests, règles CLAUDE.md, emballage des erreurs, concurrence et limites du mode Plan.
Sources: Master Claude Code in Golang: 12 Patterns for Agentic Developers
Les logiciels sont désormais développés différemment. Moins de personnes tapent chaque ligne elles-mêmes, et davantage utilisent des outils pour guider le processus. Avec Claude Code, l’agent terminal d’Anthropic, un nouveau rôle est apparu : l’ingénieur agent. Les résultats positifs ne proviennent pas de prompts négligents, mais du travail au sein de systèmes réels, en s’appuyant sur la mémoire du projet et en dirigeant le modèle depuis la ligne de commande.
La vérité brutale est qu’ouvrir une shell et taper claude "build a Golang REST API" génère un codebase désordonné. Utiliser Claude Code sur des projets Go 1.26 en production est difficile au début. Avec le temps, des habitudes se développent qui permettent d’obtenir du code Go solide et présentant un aspect normal. Voici douze d’entre elles.
1. Prompts axés sur l’interface
Idee : Plutôt que de demander un système complexe d’un seul coup, définissez d’abord l’interface Go. Cela fixe les règles, et le modèle génère ensuite du code pour les respecter.
Meilleur usage : Pour des services qui communiquent avec des bases de données, des API externes ou une logique de domaine particulière. Cela empêche également Claude d’inventer des méthodes qui n’existent pas.
# Terminal Command:
claude "Implement the PaymentGateway interface using Stripe in stripe.go. Ensure all methods return mapped domain errors, not raw stripe errors."
// Go Interface Contract:
type PaymentGateway interface {
Charge(ctx context.Context, amount int64) (string, error)
Refund(ctx context.Context, transactionID string) error
}
2. Génération pilotée par des tests
Méthode : Le développement piloté par des tests est encore amélioré. Écrivez les tests manuellement ou demandez à l’IA de les rédiger. Comme Claude Code peut exécuter des commandes shell, il peut lancer la suite de tests et continuer à corriger l’implémentation jusqu’à ce que tout passe.
Utile pour : Les calculs mathématiques complexes, les analyseurs de texte et tout ce qui présente des cas limites gênants.
# Terminal Command:
claude "Run `go test -v ./calc` and implement calculator.go to make these exact tests pass without changing the test assertions."
// Go Test File:
func TestCalculateDiscount(t *testing.T) {
result := CalculateDiscount(100, "VIP")
if result != 80 {
t.Errorf("Expected 80, got %d", result)
}
}
3. Appliquer les règles de contexte avec CLAUDE.md
Concept : Les modèles oublient parfois les conventions de Go concernant context. La mémoire de projet résout ce problème de manière définitive. Placez les règles de l’équipe dans un fichier CLAUDE.md et Claude Code les respectera à chaque session.
Utilisation adaptée : Les appels réseau, l’accès aux bases de données et tout ce qui est suffisamment lent pour nécessiter une annulation.
# Excerpt from CLAUDE.md:
## Go Conventions
Rule: Every exported I/O or database method MUST accept `context.Context` as its first parameter and pass it to the underlying driver (e.g., using `QueryRowContext`).
4. Encapsulation explicite des erreurs
Principe : Les erreurs descriptives ne sont pas vraiment appréciées des développeurs Go, mais elles sont nécessaires. Laisser Claude faire à sa guise le conduit généralement à renvoyer un simple err. Il faut lui indiquer d’utiliser fmt.Errorf avec le format %w afin que la chaîne d’erreurs soit conservée.
Utilisation typique : Toute appel à la bibliothèque standard ou à un package tiers susceptible d’échouer.
# Terminal Command:
claude "Refactor config.go. If os.Open fails, wrap the error with context using fmt.Errorf and the %w verb."
// Generated Go Code:
file, err := os.Open("config.json")
if err != nil {
return fmt.Errorf("failed to open config file: %w", err)
}
5. Structure de base pour la concurrence
Élément clé : La concurrence en Go est très puissante mais facile à mal utiliser. Plutôt que de demander quelque chose de plus rapide, précisez les primitives souhaitées, comme un sync.WaitGroup ou des canaux tamponnés. Ne laissez pas l’IA deviner.
Utile pour : Les tâches par lots, les groupes de travail et les pipelines à diffusion élargie ou concentrée.
# Terminal Command:
claude "Implement a worker pool for the Job slice in worker.go. Use a buffered channel of size 5 and a sync.WaitGroup. Ensure the WaitGroup is closed cleanly."
// Go Code Scaffold:
jobs := make(chan Job, 5)
var wg sync.WaitGroup
// Claude generates the exact worker loop here based on the constraints
6. Développement piloté par les types
T technique : Cessez d’utiliser des chaînes de caractères pour tout. Les ingénieurs aguerris demandent à Claude des types personnalisés pour les identifiants et les états, afin que le compilateur strict de Go assure le contrôle.
Idéal pour : Des structures encombrées de simples chaînes de caractères ou d’entiers.
# Terminal Command:
claude "Refactor the User struct. Change all string IDs to a custom type UserID string, and ensure all functions accepting an ID use this new type."
// Generated Go Code:
type UserID string
type User struct {
ID UserID
Email string
}
7. Directives d’injection de dépendances
Idée principale : Laisser une IA faire ce qu’elle veut, elle connectera directement une structure à la base de données dans son constructeur. Forcer l’injection de dépendances en lui indiquant d’accepter des collaborateurs en tant qu’arguments.
Le plus utile pour : Les gestionneurs, les services et les repositories qui doivent être testés unitairement par la suite.
# Terminal Command:
claude "Rewrite NewOrderService. Do not initialize the logger inside. Pass a *zap.Logger and a PaymentGateway interface as dependencies."
// Generated Go Code:
func NewOrderService(logger *zap.Logger, gateway PaymentGateway) *OrderService {
return &OrderService{
logger: logger,
gateway: gateway,
}
}
8. Ajustement basé sur des benchmarks
Le truc : Deviner quel code est lent est une perte de temps. Exécutez les benchmarks standard de Go et redirigez la sortie vers la CLI de Claude Code, puis demandez une correction pour les problèmes de mémoire. Même avec le collecteur de déchets Green Tea dans Go 1.26, les allocations méritent toujours une attention particulière.
Idéal pour : Les chemins d’exécution fréquents où le collecteur de déchets est soumis à forte pression.
# Terminal command piping benchmark results directly to Claude Code:
go test -bench . -benchmem | claude "Our allocs/op is too high in the parser. Rewrite the parse function to use a sync.Pool for the byte slices."
// Generated Go Code:
var bufferPool = sync.Pool{
New: func() any {
b := make([]byte, 1024)
return &b
},
}
9. Structures de types à partir de données brutes
Méthode : Écrire manuellement des balises JSON ou XML est fastidieux. Donnez le JSON brut à Claude afin qu’il génère la structure Go exacte avec toutes les balises en place.
Utilisation : Consommer des webhooks de tiers, ou développer des API avec des frameworks tels que Gin ou Fiber.
# Terminal Command:
claude "Create a Go struct from this JSON payload. Add `json` tags, and include `validate` tags ensuring the email is valid and the age is >= 18."
// Generated Go Code:
type RegistrationRequest struct {
Email string `json:"email" validate:"required,email"`
Age int `json:"age" validate:"gte=18"`
}
10. Idiomatic GoDoc
Fonctionnement : La documentation est une tâche fastidieuse, mais un bon code en a besoin. Demandez à Claude Code de lire un fichier et de générer des commentaires GoDoc naturels pour chaque identifiant exporté. Il peut même être configuré pour s’exécuter automatiquement.
Idéal pour : Préparer un package pour le code open source, ou maintenir le code d’une équipe en ordre.
# Terminal Command:
claude "Add GoDoc comments to all exported types and functions in user_repo.go. Start the comment with the name of the identifier."
// Generated Go Code:
// UserRepository handles database operations for the User entity.
type UserRepository struct {
db *sql.DB
}
11. La boucle des erreurs de compilation
Modèle :Lorsqu’une compilation échoue, il est souvent inutile de corriger manuellement la faute de frappe. Claude Code peut exécuter la compilation, lire les messages d’erreur en rouge et résoudre le problème, en boucle jusqu’à ce que le code se compile.
À utiliser pour : Les cycles d’importation, ou les cinquante erreurs de type laissées par une grande refonte.
# Terminal Command:
claude "Run `go build ./...`. If it fails with type conversion errors, fix the casts in handler.go and retry until it compiles cleanly."
// Claude correctly casts the primitive to the custom type to fix the build:
userID := UserID(user.ID)
err := repo.GetByID(ctx, userID)
12. Limites architecturales avec le mode Plan
Règle générale : Les modèles ont tendance à brouiller les couches, par exemple en intégrant directement du SQL brut dans un gestionnaire HTTP. Les limites doivent être définies explicitement. Le mode Plan de Claude Code vous permet d’examiner l’approche proposée avant qu’il ne génère 500 lignes de code inutilisable.
Environnement idéal : Maintenir une application propre et conforme aux règles du Domain-Driven Design.
# Terminal Command:
claude "Create a new Order handler. Rule: Do not import the 'database/sql' package in this file. You may only interact with the database via the OrderUseCase interface. Use plan mode to show me the approach first."
// Generated Go Code:
func (h *OrderHandler) Create(w http.ResponseWriter, r *http.Request) {
// Claude generates clean HTTP handling without leaking DB logic here
}
Guider plutôt que lutter
L’image du programmeur solitaire qui tape sans relâche dans un sous-sol sombre s’estompe. Ceux qui savent expliquer clairement ce qu’ils veulent, établir des règles strictes et laisser l’IA s’occuper du travail pénible peuvent consacrer leur temps aux questions architecturales intéressantes. L’application de ces douze modèles signifie ne plus lutter contre l’outil. Claude Code est ainsi orienté vers un Go sûr, rapide et, au meilleur sens du terme, ordinaire.
Nul ne écrit du code parfait du premier coup, et Claude non plus. Avec les bonnes règles en place, on peut y arriver très près.
Lectures complémentaires
- Notes pratiques : Meilleures pratiques Claude Code : 12 patterns utilisés par les ingénieurs agents — Guide détaillé des Notes pratiques : Meilleures pratiques Claude Code : 12 patterns utilisés par les ingénieurs agents : contrats, vérifications et emplacements de code prêts à l’emploi pour les équipes qui adoptent ce pattern.
- Comment Claude Code fonctionne : compétences, sous-agents, MCP, hooks, plugins — Carte claire des éléments constitutifs de Claude Code, couvrant CLAUDE.md, les compétences, les sous-agents, MCP, les hooks, les commandes et les plugins, ainsi que les moments où chacun d’eux doit être utilisé.