Communitygithub.com

lawzava/megapowers

Skills, Plugins und Hooks, die die Arbeitsweise von Codierungs-Agenten verändern — Claude Code, Codex, OpenCode, Antigravity. Gemessen, nicht nach Gefühl.

Was ist megapowers?

Diese Fähigkeit bietet eine umfassende Sammlung von Go-Entwurfsmustern und Best Practices, die speziell für KI-Codierungsagenten wie Claude Code, Codex, OpenCode und Antigravity optimiert sind. Sie konzentriert sich auf die Designentscheidungen und nicht auf einfache Nebenläufigkeitsmechaniken, die moderne Modelle bereits korrekt beherrschen. Die Anleitung deckt funktionale Optionen für flexible Konstruktoren, kleine Schnittstellen zur losen Kopplung, Abhängigkeitsinjektion, Worker-Pools und Kontextweitergabe für die Fehlerbehandlung ab. Darüber hinaus enthält sie detaillierte Richtlinien zur Paketorganisation, testgetriebenen Entwicklung mit tabellenbasierten Tests und die Verwendung von Sentinel-Fehlern. Für Entwickler, die an Go-Projekten mit KI-Assistenz arbeiten, stellt diese Fähigkeit sicher, dass der generierte Code idiomatisch, wartbar und den etablierten Konventionen folgt, wodurch die Codequalität und Konsistenz in verschiedenen Codierungsagenten verbessert wird.

Funktioniert mit✓Claude Code✓Codex CLI~Cursor✓Antigravity✓OpenCode
npx skills add lawzava/megapowers

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Go Patterns

Gemessen: Aktuelle Frontier- und kleine Claude-Modelle schreiben die gängigen Nebenläufigkeitsmechaniken hier (Worker-Pools, Pipeline-Stufen, Channel-Schließen) bereits im ersten Versuch korrekt ohne diese Fähigkeit — eine kontrollierte Studie ergab null Korrektheits-Spielraum, 184/184 bestanden in beiden Armen (die evals/RESULTS.md §2 des Repos). Greifen Sie zu dieser Fähigkeit für die Entwurfsentscheidungen — Schnittstellen, Abhängigkeitsverdrahtung, Fehlergestaltung, Paketlayout — als Überprüfungs-Checkliste oder beim Steuern schwächerer Modelle; nicht weil ein aktuelles Modell sonst in einen Deadlock geraten würde.

Umfang: Go-Dateien, go.mod und go.sum. Ursprung: Abgeleitet von Everything Claude Code (MIT, (c) 2026 Affaan Mustafa).

Diese Fähigkeit bietet umfassende Go-Patterns, die allgemeine Entwurfsprinzipien mit Go-spezifischen Redewendungen erweitern.

Funktionale Optionen

Verwenden Sie das Muster der funktionalen Optionen für eine flexible Konstruktorkonfiguration:

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
}

Vorteile:

  • Rückwärtskompatible API-Entwicklung
  • Optionale Parameter mit Standardwerten
  • Selbstdokumentierende Konfiguration

Kleine Schnittstellen

Definieren Sie Schnittstellen dort, wo sie verwendet werden, nicht dort, wo sie implementiert werden.

Prinzip: Akzeptiere Schnittstellen, gib Strukturen zurück

// Gut: Kleine, fokussierte Schnittstelle am Verwendungspunkt definiert
type UserStore interface {
    GetUser(id string) (*User, error)
}

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

Vorteile:

  • Einfachere Tests und Mocks
  • Lose Kopplung
  • Klare Abhängigkeiten

Abhängigkeitsinjektion

Verwenden Sie Konstruktorfunktionen zum Injizieren von Abhängigkeiten:

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

Muster:

  • Konstruktorfunktionen (New*-Präfix)
  • Explizite Abhängigkeiten als Parameter
  • Konkrete Typen zurückgeben
  • Abhängigkeiten im Konstruktor validieren

Nebenläufigkeitsmuster

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)
            }
        }()
    }
    // Ergebnisse schließen, sobald alle Arbeiter fertig sind — in einer separaten
    // Goroutine, damit diese Funktion sofort zurückkehrt und der Aufrufer über
    // Ergebnisse iterieren kann, während die Arbeiter noch produzieren. Ein
    // Inline-wg.Wait() hier führt zu einem Deadlock: die Arbeiter blockieren beim
    // Senden an results, bis ein Leser sie abnimmt, aber der Leser läuft erst,
    // nachdem workerPool zurückgekehrt ist.
    go func() {
        wg.Wait()
        close(results)
    }()
}

Kontextweitergabe

Übergeben Sie den Kontext immer als ersten Parameter:

func FetchUser(ctx context.Context, id string) (*User, error) {
    // Auf Kontextabbruch prüfen
    select {
    case <-ctx.Done():
        return nil, ctx.Err()
    default:
    }
    // ... Abrufflogik
}

Fehlerbehandlung

Fehlerumwicklung

if err != nil {
    return fmt.Errorf("Fehler beim Abrufen von Benutzer %s: %w", id, err)
}

Benutzerdefinierte Fehler

type ValidationError struct {
    Field string
    Msg   string
}

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

Sentinel-Fehler

var (
    ErrNotFound = errors.New("nicht gefunden")
    ErrInvalid  = errors.New("ungültige Eingabe")
)

// Prüfung mit errors.Is
if errors.Is(err, ErrNotFound) {
    // Nicht gefunden behandeln
}

Paketorganisation

Struktur

project/
├── cmd/              # Hauptanwendungen
│   └── server/
│       └── main.go
├── internal/         # Privater Anwendungscode
│   ├── domain/       # Geschäftslogik
│   ├── handler/      # HTTP-Handler
│   └── repository/   # Datenzugriff
└── pkg/              # Öffentliche Bibliotheken

Namenskonventionen

  • Paketnamen: Kleinbuchstaben, einzelnes Wort
  • Stottern vermeiden: user.User nicht user.UserModel
  • internal/ für privaten Code verwenden
  • main-Paket minimal halten

Testmuster

Tabellengetriebene Tests

func TestValidate(t *testing.T) {
    tests := []struct {
        name    string
        input   string
        wantErr bool
    }{
        {"gültig", "[email protected]", false},
        {"ungültig", "keine-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("Fehler %v erhalten, wantErr %v", err, tt.wantErr)
            }
        })
    }
}

Test-Helfer

// Importieren Sie den reinen Go-Treiber: _ "modernc.org/sqlite" (registriert als "sqlite").
// Verwenden Sie NICHT "sqlite3" (mattn/go-sqlite3) — es benötigt CGO und bricht
// CGO_ENABLED=0 static builds. Das greenfield-go-stack-Bündel verlangt pure-Go/CGO-frei.
func testDB(t *testing.T) *sql.DB {
    t.Helper()
    db, err := sql.Open("sqlite", ":memory:")
    if err != nil {
        t.Fatalf("Fehler beim Öffnen der Testdatenbank: %v", err)
    }
    // Eine ":memory:"-Datenbank ist privat für eine einzelne Verbindung, und database/sql
    // ist ein fauler Pool: ohne dies erhält jede gepoolte Verbindung ihre EIGENE leere
    // Datenbank, sodass eine in einer Verbindung erstellte Tabelle in der nächsten fehlt.
    // Das Anheften des Pools an eine Verbindung sorgt dafür, dass der gesamte Test eine
    // In-Memory-DB gemeinsam nutzt. Einschränkung: Bei einer einzelnen Verbindung hält
    // diese Verbindung, während eine Transaktion offen ist (db.Begin), die einzige
    // Verbindung — leiten Sie ALLE Arbeiten durch die Transaktion, bis Commit/Rollback;
    // eine gleichzeitige db.Query auf dem Pool würde darauf warten blockieren. Wenn ein
    // Test wirklich mehrere Live-Verbindungen benötigt, verwenden Sie stattdessen ein
    // Shared-Cache-DSN ("file:testdb?mode=memory&cache=shared") und halten Sie mindestens
    // 1 Verbindung offen, damit die In-Memory-DB nicht gelöscht wird.
    db.SetMaxOpenConns(1)
    t.Cleanup(func() { db.Close() })
    return db
}

Wann diese Fähigkeit verwendet werden sollte

  • Entwerfen von Go-APIs und -Paketen
  • Implementieren von nebenläufigen Systemen
  • Strukturieren von Go-Projekten
  • Schreiben von idiomatischem Go-Code
  • Refactoring von Go-Codebasen

Verwandte Skills