CommunityCodierung & Entwicklunggithub.com

samber/golang-gopls

Golang semantische Code-Intelligenz mittels `gopls`, dem offiziellen Go-Sprachserver – Gehe-zu-Definition, Referenzen suchen, Aufruf-/Implementierungshierarchie, Workspace-Symbolsuche, Paket-API-Erkennung, Diagnose, sicheres Umbenennen, Refactorings (Extrahieren/Einfügen/Ausfüllen/Code-Aktionen umschreiben), Formatierung und generierte Tests. Erreicht einen Agenten über gopls' eigenen MCP-Server (`go_*`-Tools), das native `LSP`-Tool von Claude Code oder das `gopls`-CLI.

Was ist golang-gopls?

Dieses Skill bietet umfassende semantische Code-Intelligenz für Go-Projekte, basierend auf `gopls`, dem offiziellen Go-Sprachserver. Es ist für KI-Agenten wie Claude Code oder Cursor konzipiert und ermöglicht präzise Navigation durch Go-Code, das Auffinden von Definitionen und Referenzen, die Analyse von Aufruf- und Implementierungshierarchien sowie die Durchführung sicherer Refactorings wie Umbenennungen, Extraktionen und Code-Neustrukturierungen. Das Skill unterstützt drei Integrationswege: den bevorzugten MCP-Server von gopls (toolbasiert, ideal für agentenorientierte Workflows), das native `LSP`-Tool von Claude Code (mit automatischer Diagnose nach jeder Änderung) und das `gopls`-CLI als Fallback. Es ist besonders nützlich für Entwickler, die Go-Code verstehen, überarbeiten oder debuggen müssen, ohne auf textbasierte Suche angewiesen zu sein – es liefert typbasierte Ergebnisse (Typen, Aufrufgraphen, Shadowing, Implementierungsbeziehungen) und funktioniert ausschließlich mit dem lokal aufgelösten Build (Workspace plus Abhängigkeiten aus `go.sum`).

Funktioniert mit✓Claude Code✓Codex CLI✓Cursor
npx skills add https://github.com/samber/cc-skills-golang/tree/main/skills/golang-gopls

Installed? Explore more Codierung & Entwicklung skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

In Ihrer bevorzugten KI fragen

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

Dokumentation

Persona: Du bist ein Go-Entwickler, der semantische Code-Intelligenz anstelle von grep verwendet, wenn es um den aufgelösten Build geht – grep findet Text, gopls findet Bedeutung (Typen, Aufrufgraphen, Shadowing, Implementierungsbeziehungen).

Abhängigkeiten: gopls – go install golang.org/x/tools/gopls@latest (v0.20+). Das native LSP-Tool benötigt zusätzlich ENABLE_LSP_TOOL=1 und das Marketplace-Plugin gopls-lsp@claude-plugins-official (siehe references/mcp.md).

gopls ist der offizielle Go-Sprachserver. Er beantwortet nur Fragen zu deinem spezifischen, lokal aufgelösten Build – deinem Workspace plus allen Abhängigkeiten exakt wie in go.sum festgelegt, einschließlich replace-Direktiven. Für ein Paket, das nicht Teil dieses Builds ist (Versionen, Dokumentation, Lizenzen, CVEs von etwas, das du noch nicht hinzugefügt hast), → Siehe Skill samber/cc-skills-golang@golang-pkg-go-dev (godig) stattdessen.

Drei Wege, gopls zu erreichen

Nicht austauschbar – wähle basierend auf dem, was du bereits weißt und was du zurückbekommst:

  • gopls' eigener MCP-Server (bevorzugt für die meisten Aufgaben) – maßgeschneidert für Agenten: Tools akzeptieren Namen, Dateipfade und unscharfe Abfragen anstelle von rohen Cursorpositionen. Einmal pro Maschine registrieren: claude mcp add gopls -- gopls mcp. Läuft headless über stdio, kein Editor angeschlossen, sieht nur auf der Festplatte gespeicherte Dateien – der richtige Standard für einen agentenorientierten Workflow. Siehe references/mcp.md für jedes Tool.
  • Das native LSP-Tool – Claude Codes integrierte Editor-artige Integration. Standardmäßig deaktiviert: Setze ENABLE_LSP_TOOL=1, installiere gopls, und installiere das offizielle Marketplace-Plugin gopls-lsp@claude-plugins-official, um es als Go-Sprachserver zu verdrahten. Operationen (goToDefinition, findReferences, hover, documentSymbol, workspaceSymbol, goToImplementation, Aufrufhierarchie) sind nach line/character indiziert, daher sind sie am nützlichsten, sobald du bereits eine Position hast – typischerweise direkt nach einem grep oder einem Lesevorgang. Einzigartiger Wert: Compilerdiagnosen werden automatisch nach jeder Bearbeitung in den Kontext eingefügt, kein expliziter Aufruf erforderlich.
  • Das gopls-CLI – dieselbe Engine, aufgerufen als gopls <command> <file:line:col>. Das Go-Team dokumentiert es als experimentell und nur zum Debuggen – "nicht effizient, vollständig, flexibel oder offiziell unterstützt." Verwende es, wenn weder MCP noch das native Tool eingerichtet sind, oder für einen einmaligen skriptgesteuerten Check. Positionen sind file:line:col (1-basiert, UTF-8-Bytes) oder file:#offset (0-basiert). Siehe references/cli.md.

Bevorzugungsreihenfolge: MCP → natives LSP → CLI. MCP-Tools passen zu der Denkweise eines Agenten (nach Name/Pfad, nicht Cursorposition); das native Tool fügt kostenlose automatische Diagnose hinzu; das CLI ist der dokumentierte letzte Ausweg. Verbinde so viele wie verfügbar und lass die Aufgabe das Tool auswählen – eine Abfrage, für die du bereits eine line:col hast, ist über LSP günstig, eine "wo ist X"-Abfrage ist über go_search günstig, ein schneller unbeaufsichtigter Check ist über das CLI günstig.

Fähigkeit → CLI → MCP → natives LSP

Vollständige Zuordnung jeder Fähigkeit zu ihrem CLI-Befehl, MCP-Tool und nativen LSP-Op: references/matrix.md.

Anwendungsfälle

  • Navigation – springe zu einer Definition, einer Implementierung oder verfolge einen Aufrufgraphen, bevor du Code anfasst, den du nicht geschrieben hast. Details: references/features.md.
  • Code-Erkundung – lerne die Form eines Workspaces (go_workspace), suche unscharf nach einem Symbol, das du nicht genau platzieren kannst (go_search), oder lies die öffentliche Oberfläche einer Abhängigkeit (go_package_api), bevor du sie verwendest.
  • Dokumentation – fahre mit der Maus für Typ-/Dok-/Größeninfo, Signaturhilfe beim Aufruf einer Funktion oder durchsuche gerenderte Paketdokumentation (source.doc, einschließlich interner Pakete, die pkg.go.dev nie sieht).
  • Diagnose & Sicherheit – Compiler- und Analyzerfehler nach jeder Bearbeitung (go_diagnostics / automatisch mit LSP), plus eine einfache go_vulncheck-Erreichbarkeitsprüfung: einmal als Basislinie direkt nach der Erkennung des Workspaces und erneut nach jeder go.mod-Änderung.
  • Formatierung – kanonische gofmt-äquivalente Formatierung und Importorganisation, sowohl skriptgesteuert als auch code-aktionsgetrieben.
  • Refactoring – sicheres Umbenennen (blockiert eine Änderung, die die Interface-Erfüllung brechen würde), Extrahieren/Einfügen und die gesamte refactor.rewrite.*-Familie (Struct/Switch ausfüllen, If umkehren, Zeilen teilen/verbinden, unbenutzten Parameter entfernen, Struct-Tags hinzufügen, Interface implementieren). Vollständiger Katalog mit Fallstricken: references/features.md.

Effiziente Workflows

Diese Lese-/Bearbeitungs-Workflows kodieren die Reihenfolge, die redundante Abfragen und halb angewandte Bearbeitungen vermeidet – behandle jeden Schritt als erforderlich, nicht optional, selbst um eine Runde zu sparen.

  • Sitzungsstart – rufe go_workspace einmal auf, um zu erkennen, ob dies überhaupt ein Go-Workspace ist; wenn ja, folge sofort mit einer Basislinien-go_vulncheck, um Schwachstellen aufzudecken, die der Workspace bereits trägt. Dies ist bedingungslos, getrennt von der späteren Prüfung des Bearbeitungs-Workflows nach einer Abhängigkeitsänderung.

Lese-Workflow (verstehen, bevor du etwas anfasst):

  1. go_workspace – Layout (Module/Workspace/GOPATH); derselbe Aufruf wie die Sitzungsstart-Prüfung oben, falls noch nicht ausgeführt.
  2. go_search – suche unscharf nach einem Typ/einer Funktion/Variable anhand des Namens.
  3. go_file_context – direkt nach dem ersten Lesen einer Go-Datei sehen, was sie aus dem Rest ihres Pakets einzieht; erneut ausführen, wenn sich die Abhängigkeiten dieser Datei ändern.
  4. go_package_api – öffentliche Oberfläche einer Drittanbieter-Abhängigkeit oder eines Geschwisterpakets, ohne jede Datei zu lesen.

Bearbeitungs-Workflow (iterieren, bis die Diagnose sauber ist):

  1. Zuerst lesen (Workflow oben).
  2. go_symbol_references vor dem Ändern einer Definition – beurteile die Auswirkungsbreite, lies dann jede referenzierende Datei, die eine passende Bearbeitung benötigt.
  3. Führe alle geplanten Bearbeitungen durch, einschließlich der Änderungen an den Referenzstellen, bevor du fortfährst.
  4. go_diagnostics für jede geänderte Datei – obligatorisch nach jeder Änderung, kein optionaler Bereinigungsschritt.
  5. Behebe gemeldete Fehler: Überprüfe jede vorgeschlagene Quick-Fix-Diff, bevor du sie anwendest, führe dann die Diagnose erneut aus, um zu bestätigen, dass der Fix angekommen ist. Ignoriere Hint/Info-Diagnosen, die nichts mit der Aufgabe zu tun haben. Eine Diagnosemeldung kann den umgebenden Quellcode paraphrasieren, anstatt ihn wörtlich zu zitieren.
  6. Nur wenn sich die go.mod-Abhängigkeiten geändert haben, führe go_vulncheck für den gesamten Workspace aus – nachdem die Diagnose sauber ist, nicht davor.
  7. Führe go test <changed-package-paths> aus – nicht ./..., sofern nicht ausdrücklich danach gefragt.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

samber/golang-benchmark

Golang benchmarking, profiling, and performance measurement. Use when writing, running, or comparing Go benchmarks, profiling hot paths with pprof, interpreting CPU/memory/trace profiles, analyzing results with benchstat, setting up CI benchmark regression detection, or investigating production performance with Prometheus runtime metrics. Also use when the developer needs deep analysis on a specific performance indicator - this skill provides the measurement methodology, while `samber/cc-skills-golang@golang-performance` provides the optimization patterns.

samber/golang-cli

Golang CLI application development. Use when building, modifying, or reviewing a Go CLI tool — especially for command structure, flag handling, configuration layering, version embedding, exit codes, I/O patterns, signal handling, shell completion, argument validation, and CLI unit testing. Also triggers when code uses cobra, viper, or urfave/cli. For cobra-specific APIs → See `samber/cc-skills-golang@golang-spf13-cobra` skill; for viper configuration layering → See `samber/cc-skills-golang@golang-spf13-viper` skill.

samber/golang-code-style

Golang code style conventions — line length and breaking, variable declarations, control flow clarity, when comments help vs hurt. Use when writing or reviewing Go code, asking about style or clarity, or establishing project coding standards. Not for naming conventions (→ See `samber/cc-skills-golang@golang-naming` skill), linter configuration (→ See `samber/cc-skills-golang@golang-lint` skill), or doc comments (→ See `samber/cc-skills-golang@golang-documentation` skill).

samber/golang-concurrency

Golang concurrency patterns. Use when writing or reviewing concurrent Go code involving goroutines, channels, select, locks, sync primitives, errgroup, singleflight, worker pools, or fan-out/fan-in pipelines. Also triggers when you detect goroutine leaks, race conditions, channel ownership issues, or need to choose between channels and mutexes.

samber/golang-context

Idiomatic context.Context usage in Golang — propagation through API boundaries, cancellation, timeouts and deadlines, request-scoped values, context.WithoutCancel for background work outliving requests. Apply when designing context propagation across layers, debugging leaked or unexpired contexts, choosing between context.Background/TODO/WithoutCancel, or storing values in context. Not for code that merely accepts ctx as first parameter.

samber/golang-continuous-integration

CI/CD pipeline configuration using GitHub Actions for Golang projects — testing, linting, SAST, security scanning, code coverage, Dependabot, Renovate, GoReleaser, code review automation, and release pipelines. Use when setting up or improving Go project CI, configuring GitHub Actions workflows, adding linters or security scanners, automating dependency updates, or adding quality gates.

samber/golang-database

Comprehensive guide for Go database access — parameterized queries, struct scanning, NULLable columns, transactions, isolation levels, SELECT FOR UPDATE, connection pool, batch processing, context propagation, and migration tooling. Use when writing, reviewing, or debugging Golang code that interacts with PostgreSQL, MariaDB, MySQL, or SQLite; for database testing; or for questions about database/sql, sqlx, or pgx. Does NOT generate database schemas or migration SQL.

samber/golang-data-structures

Golang data structures — slices (internals, capacity growth, preallocation, slices package), maps (internals, hash buckets, maps package), arrays, container/list/heap/ring, strings.Builder vs bytes.Buffer, generic collections, pointers (unsafe.Pointer, weak.Pointer), and copy semantics. Use when choosing or optimizing Go data structures, implementing generic containers, using container/ packages, unsafe or weak pointers, or questioning slice/map internals.

samber/golang-dependency-injection

Comprehensive guide for dependency injection (DI) in Golang. Covers why DI matters (testability, loose coupling, separation of concerns, lifecycle management), manual constructor injection, and DI library comparison (google/wire, uber-go/dig, uber-go/fx, samber/do). Use this skill when designing service architecture, setting up dependency injection, refactoring tightly coupled code, managing singletons or service factories, or when the user asks about inversion of control, service containers, or wiring dependencies in Go. For a specific DI library, → See `samber/cc-skills-golang@golang-google-wire`, `samber/cc-skills-golang@golang-uber-dig`, `samber/cc-skills-golang@golang-uber-fx`, or `samber/cc-skills-golang@golang-samber-do` skills.

samber/golang-dependency-management

Dependency management strategies for Golang projects — go.mod management, installing/upgrading packages, Minimal Version Selection, vulnerability scanning, outdated dependency tracking, binary size analysis, Dependabot/Renovate setup, conflict resolution, and go.work workspaces. Use when adding, removing, or upgrading Go dependencies, auditing vulnerabilities, resolving version conflicts, or setting up automated dependency updates.

samber/golang-design-patterns

Idiomatic Golang design patterns — functional options, constructors, error flow and cascading, resource management and lifecycle, graceful shutdown, resilience, architecture, dependency injection, data handling, streaming, and more. Apply when explicitly choosing between architectural patterns, implementing functional options, designing constructor APIs, setting up graceful shutdown, applying resilience patterns, or asking which idiomatic Go pattern fits a specific problem.

samber/golang-documentation

Comprehensive documentation guide for Golang projects, covering godoc comments, README, CONTRIBUTING, CHANGELOG, Go Playground, Example tests, API docs, and llms.txt. Use when writing or reviewing doc comments, documentation, adding code examples, setting up doc sites, or discussing documentation best practices. Triggers for both libraries and applications/CLIs.

samber/golang-error-handling

Idiomatic Golang error handling — creation, wrapping with %w, errors.Is/As, errors.Join, custom error types, sentinel errors, panic/recover, the single handling rule, structured logging with slog, HTTP request logging middleware, and samber/oops for production errors. Built to make logs usable at scale with log aggregation 3rd-party tools. Apply when creating, wrapping, inspecting, or logging errors in Go code. For samber/oops specifics → See `samber/cc-skills-golang@golang-samber-oops` skill; for slog handler ecosystem → See `samber/cc-skills-golang@golang-samber-slog` skill.

samber/golang-google-wire

Compile-time dependency injection in Golang using google/wire — wire.NewSet, wire.Build, wire.Bind (interface→concrete), wire.Struct, wire.Value, wire.InterfaceValue, wire.FieldsOf, cleanup functions, //go:build wireinject injector files, and generated wire_gen.go. Apply when using or adopting google/wire, when the codebase imports `github.com/google/wire`, or when wiring an application graph at compile time via `wire.Build`. For runtime DI with reflection, see `samber/cc-skills-golang@golang-uber-dig` skill.

samber/golang-graphql

Implements GraphQL APIs in Golang using gqlgen or graphql-go. Apply when building GraphQL servers, designing schemas, writing resolvers, handling subscriptions, or integrating GraphQL with existing Go HTTP services. Also apply when the codebase imports `github.com/99designs/gqlgen` or `github.com/graph-gophers/graphql-go`.

samber/golang-grpc

Provides gRPC usage guidelines, protobuf organization, and production-ready patterns for Golang microservices. Use when implementing, reviewing, or debugging gRPC servers/clients, writing proto files, setting up interceptors, handling gRPC errors with status codes, configuring TLS/mTLS, testing with bufconn, or working with streaming RPCs.

samber/golang-how-to

Golang skills orchestrator — always active on any Golang coding, review, debug, or setup task. Reads the task context and loads the most relevant skills from samber/cc-skills-golang, often multiple at once: writing a gRPC service loads golang-grpc + golang-testing + golang-error-handling; debugging a panic loads golang-troubleshooting + golang-safety; auditing security loads golang-security + golang-lint + golang-safety. Also: disambiguates competing clusters when two skills seem to overlap (performance vs benchmark vs troubleshooting, samber/lo vs mo vs ro, DI cluster, safety vs security), and configures the project's agent-config file (CLAUDE.md, AGENTS.md, GEMINI.md, Cursor rules, or Copilot instructions) to force-trigger skills in a project (/golang-how-to configure).

samber/golang-lint

Linting best practices and golangci-lint configuration for Golang projects — running linters, configuring .golangci.yml, suppressing warnings with nolint directives, interpreting lint output, and selecting linters. Use when configuring golangci-lint, asking about lint warnings or nolint suppressions, setting up code quality tooling, or choosing linters. Also use when the user mentions golangci-lint, go vet, staticcheck, or revive.

samber/golang-modernize

Modernize Golang code to use recent language features, standard library improvements, and idiomatic patterns. Trigger proactively when writing or reviewing Go code and old-style patterns are detected, or when encountering a deprecation warning. Also use when the user explicitly asks for modernization, a Go version upgrade, or a CI/tooling refresh.

samber/golang-naming

Go (Golang) naming conventions — covers packages, constructors, structs, interfaces, constants, enums, errors, booleans, receivers, getters/setters, functional options, acronyms, test functions, and subtest names. Use this skill when writing new Go code, reviewing or refactoring, choosing between naming alternatives (New vs NewTypeName, isConnected vs connected, ErrNotFound vs NotFoundError, StatusReady vs StatusUnknown at iota 0), debating Go package names (utils/helpers anti-patterns), or asking about Go naming best practices. Also trigger when the user mentions MixedCaps vs snake_case, ALL_CAPS constants, Get-prefix on getters, or error string casing. Do NOT use for general Go implementation questions that don't involve naming decisions.

Verwandte Skills