Communitygithub.com

lawzava/megapowers

Compétences, plugins et hooks qui changent la façon dont les agents de codage travaillent — Claude Code, Codex, OpenCode, Antigravity. Mesuré, pas ressenti.

Qu'est-ce que megapowers ?

Ce skill, intitulé « Go Patterns », fournit un ensemble de modèles de conception idiomatiques pour le langage Go, destiné aux agents de codage comme Claude Code, Codex, OpenCode et Antigravity. Il couvre des patterns fondamentaux tels que les options fonctionnelles, les petites interfaces, l'injection de dépendances, les modèles de concurrence (worker pool, propagation de contexte), la gestion d'erreurs (emballage, erreurs sentinelles), l'organisation de packages et les tests (tests table-driven, helpers). Le skill met en garde : les modèles Claude récents maîtrisent déjà les mécanismes de concurrence courants (sans ce skill, 184/184 tests passent), mais le skill reste utile pour les choix de conception avancés, les revues de code, ou pour piloter des modèles plus faibles. Il est dérivé d'Everything Claude Code et se concentre sur des idiomes Go précis et éprouvés, avec des exemples de code prêts à l'emploi.

Compatible avec✓Claude Code✓Codex CLI~Cursor✓Antigravity✓OpenCode
npx skills add lawzava/megapowers

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Go Patterns

Mesuré : la frontière actuelle et les petits modèles Claude écrivent déjà correctement les mécanismes de concurrence courants (worker pools, étapes de pipeline, fermeture de canaux) en un seul coup sans ce skill — une étude contrôlée n'a trouvé aucune marge d'amélioration en termes de correction, 184/184 réussissant dans les deux bras (section 2 du evals/RESULTS.md du dépôt). Utilisez ce skill pour les choix de conception — interfaces, câblage des dépendances, mise en forme des erreurs, organisation des packages — comme liste de contrôle de révision, ou lorsque vous pilotez des modèles plus faibles ; pas parce qu'un modèle actuel pourrait autrement se bloquer.

Portée : fichiers Go, go.mod et go.sum. Origine : Dérivé de Everything Claude Code (MIT, (c) 2026 Affaan Mustafa).

Ce skill fournit des modèles Go complets qui étendent les principes de conception courants avec des idiomes spécifiques à Go.

Options Fonctionnelles

Utilisez le modèle d'options fonctionnelles pour une configuration flexible du constructeur :

type Option func(*Server)

func WithPort(port int) Option {
    return func(s *Server) { s.port = port }
}

func NewServer(opts ...Option) *Server {
    s := &Server{port: 8080}
    for _, opt := range opts {
        opt(s)
    }
    return s
}

Avantages :

  • Évolution d'API rétrocompatible
  • Paramètres optionnels avec valeurs par défaut
  • Configuration auto-documentée

Petites Interfaces

Définissez les interfaces là où elles sont utilisées, pas là où elles sont implémentées.

Principe : Acceptez les interfaces, retournez les structures

// Bien : Interface petite et ciblée, définie au point d'utilisation
type UserStore interface {
    GetUser(id string) (*User, error)
}

func ProcessUser(store UserStore, id string) error {
    user, err := store.GetUser(id)
    // ...
}

Avantages :

  • Tests et simulation plus faciles
  • Couplage lâche
  • Dépendances claires

Injection de Dépendances

Utilisez les fonctions constructeur pour injecter les dépendances :

func NewUserService(repo UserRepository, logger Logger) *UserService {
    return &UserService{
        repo:   repo,
        logger: logger,
    }
}

Modèle :

  • Fonctions constructeur (préfixe New*)
  • Dépendances explicites en paramètres
  • Types concrets en retour
  • Valider les dépendances dans le constructeur

Modèles de Concurrence

Worker Pool

func workerPool(jobs <-chan Job, results chan<- Result, workers int) {
    var wg sync.WaitGroup
    for i := 0; i < workers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {
                results <- processJob(job)
            }
        }()
    }
    // Fermer results une fois que tous les workers ont terminé — dans une goroutine
    // séparée pour que cette fonction retourne immédiatement et que l'appelant puisse
    // parcourir results pendant que les workers produisent encore. Un wg.Wait() en
    // ligne ici provoquerait un interblocage : les workers bloquent l'envoi sur results
    // jusqu'à ce qu'un lecteur les vide, mais le lecteur ne s'exécute qu'après le retour
    // de workerPool.
    go func() {
        wg.Wait()
        close(results)
    }()
}

Propagation du Contexte

Passez toujours le contexte en premier paramètre :

func FetchUser(ctx context.Context, id string) (*User, error) {
    // Vérifier l'annulation du contexte
    select {
    case <-ctx.Done():
        return nil, ctx.Err()
    default:
    }
    // ... logique de récupération
}

Gestion des Erreurs

Emballage d'Erreurs

if err != nil {
    return fmt.Errorf("échec de la récupération de l'utilisateur %s : %w", id, err)
}

Erreurs Personnalisées

type ValidationError struct {
    Field string
    Msg   string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("%s : %s", e.Field, e.Msg)
}

Erreurs Sentinelles

var (
    ErrNotFound = errors.New("non trouvé")
    ErrInvalid  = errors.New("entrée invalide")
)

// Vérifier avec errors.Is
if errors.Is(err, ErrNotFound) {
    // gérer l'absence de résultat
}

Organisation des Packages

Structure

project/
├── cmd/              # Applications principales
│   └── server/
│       └── main.go
├── internal/         # Code applicatif privé
│   ├── domain/       # Logique métier
│   ├── handler/      # Gestionnaires HTTP
│   └── repository/   # Accès aux données
└── pkg/              # Bibliothèques publiques

Conventions de Nommage

  • Noms de package : minuscules, un seul mot
  • Évitez le bégaiement : user.User pas user.UserModel
  • Utilisez internal/ pour le code privé
  • Gardez le package main minimal

Modèles de Tests

Tests Table-Driven

func TestValidate(t *testing.T) {
    tests := []struct {
        name    string
        input   string
        wantErr bool
    }{
        {"valide", "[email protected]", false},
        {"invalide", "pas-un-email", true},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            err := Validate(tt.input)
            if (err != nil) != tt.wantErr {
                t.Errorf("erreur obtenue %v, wantErr %v", err, tt.wantErr)
            }
        })
    }
}

Helpers de Test

// Importez le driver pure-Go : _ "modernc.org/sqlite" (s'enregistre comme "sqlite").
// N'utilisez PAS "sqlite3" (mattn/go-sqlite3) — il nécessite CGO et casse les
// builds statiques CGO_ENABLED=0. Le bundle greenfield-go-stack impose pure-Go/CGO-free.
func testDB(t *testing.T) *sql.DB {
    t.Helper()
    db, err := sql.Open("sqlite", ":memory:")
    if err != nil {
        t.Fatalf("échec de l'ouverture de la base de test : %v", err)
    }
    // Une base ":memory:" est privée à une seule connexion, et database/sql
    // est un pool paresseux : sans cela, chaque connexion poolée obtient sa PROPRE base
    // vide, donc une table créée sur une connexion est absente de la suivante.
    // Épingler le pool à une seule connexion fait partager la même base en mémoire
    // à tout le test. Inconvénient : avec une seule connexion, tant qu'une transaction
    // est ouverte (db.Begin), cette tx détient l'unique connexion — acheminez TOUT le
    // travail via la tx jusqu'à Commit/Rollback ; une db.Query concurrente sur le pool
    // bloquerait en attendant. Si un test a vraiment besoin de plusieurs connexions
    // actives, utilisez plutôt une DSN à cache partagé
    // ("file:testdb?mode=memory&cache=shared") et gardez au moins 1 connexion ouverte
    // pour que la base en mémoire ne soit pas supprimée.
    db.SetMaxOpenConns(1)
    t.Cleanup(func() { db.Close() })
    return db
}

Quand Utiliser Ce Skill

  • Conception d'API et de packages Go
  • Implémentation de systèmes concurrents
  • Structuration de projets Go
  • Écriture de code Go idiomatique
  • Remaniement de bases de code Go

Skills associés