{"id":4365,"external_id":"plugins_6a7b1e3e30948191aea92f131b0f6ca9","name":"gophers","display_name":"Gophers","developer":"Murat Mirgün Ercan","category":"Developer Tools","listing_language":"en","listing_language_details":{"method":"cld-0.13.0/listing-v1","reliable":true,"detected_at":"2026-10-01T13:22:04Z","input_sha256":"242f8c0fbfcff20d1bab72b9858fbe7d4d53b06267042eb11e8a14fb249ed1a8","source_fields":["release.description","release.interface.short_description","release.interface.long_description"]},"version":"0.1.0","skill_count":26,"first_seen_at":"2026-09-30T22:02:35.000Z","last_seen_at":"2026-10-03T06:00:00.871Z","last_changed_at":"2026-09-30T22:02:35.000Z","install_count":null,"search_matches":[],"research_summary":null,"research_reviewed_at":null,"metadata":{"canonical_app_id":null,"connector_id":null,"created_at":"2026-08-11T13:18:08.473981Z","discoverability":"UNLISTED","id":"plugins_6a7b1e3e30948191aea92f131b0f6ca9","is_template":false,"name":"gophers","release":{"app_ids":[],"app_manifest":null,"app_templates":[],"description":"Production-grade Go programming skills for AI coding agents.","display_name":"Gophers","id":"pluginrel_296fb098355081918ad98f16c15bc77f","interface":{"brand_color":"#00ADD8","capabilities":["Read","Write"],"category":"Developer Tools","composer_icon_dark_url":null,"composer_icon_url":"https://files.openai.com/content?id=file_00000000017c81f49b59eeabe76aaeeb","default_prompt":"Review this Go change for bugs, race conditions, and idiomatic design.","default_prompts":["Review this Go change for bugs, race conditions, and idiomatic design.","Design a clean, testable Go package API for this requirement.","Diagnose this Go issue and propose a minimal, well-tested fix."],"developer_name":"Murat Mirgün Ercan","logo_url":"https://files.openai.com/content?id=file_00000000f2a081f9b9bb35c972588e0f","logo_url_dark":null,"long_description":"Get focused guidance for writing, reviewing, testing, and improving Go code. Use 26 skills covering APIs, concurrency, databases, error handling, observability, performance, documentation, and idiomatic design.","plugin_category_id":"developer tools","privacy_policy_url":"https://muratmirgun.github.io/gophers/privacy.html","screenshot_urls":[],"short_description":"Production-grade Go skills","terms_of_service_url":"https://muratmirgun.github.io/gophers/terms.html","website_url":"https://muratmirgun.github.io/gophers/"},"keywords":["go","golang","skills","code-review","testing","concurrency","observability"],"onboarding_skill_name":null,"requires_local_executor":false,"skills":[{"description":"Use when scaffolding or refactoring a Go service into a framework-agnostic clean (hexagonal) architecture: Domain, Usecase, Repository, Delivery layers, inward dependency rule, 'framework/database is a detail'. Apply when untangling a monolith or checking whether business logic is testable without HTTP or DB.","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-clean-architecture to design or review this Go service architecture.","display_name":"Go Clean Architecture","icon_large_url":null,"icon_small_url":null,"iconography":"hierarchy","short_description":"Structure Go services with clean architecture"},"name":"go-clean-architecture","plugin_release_skill_id":"pluginrsk_6a7b1e45ebf88191aa4b84493efe297f"},{"description":"Invoke this skill to systematically review a Go change against community style standards before merging. Walks the diff topic by topic — formatting, errors, naming, concurrency, interfaces, data structures, security, declarations, functions, style, logging, imports, generics, testing — flagging issues with line references and severity (must-fix / should-fix / nit). Apply proactively before any Go PR ships.","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-code-review to review this Go change and rank findings by severity.","display_name":"Go Code Review","icon_large_url":null,"icon_small_url":null,"iconography":"search","short_description":"Review Go changes for correctness and style"},"name":"go-code-review","plugin_release_skill_id":"pluginrsk_6a7b1e476cec8191b6781a8f51660a7e"},{"description":"Use when writing or reviewing Go code for clarity, formatting, control flow, variable declarations, switch usage, and function design. Covers the priority order (clarity > simplicity > concision > maintainability > consistency), gofmt rules, early-return / no-else patterns, switch over if-else chains, slice/map initialization, and value-vs-pointer choices. Apply proactively to every Go change, even when the user has not asked about style.","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-code-style to improve this Go code for clarity and idiomatic style.","display_name":"Go Code Style","icon_large_url":null,"icon_small_url":null,"iconography":"code","short_description":"Write clear and idiomatic Go code"},"name":"go-code-style","plugin_release_skill_id":"pluginrsk_6a7b1e41734c81919b125ffab37676fa"},{"description":"Use when writing or reviewing concurrent Go code — goroutines, channels, select, mutexes, atomics, errgroup, singleflight, worker pools, or fan-out/fan-in pipelines. Apply proactively whenever a goroutine is spawned, a shared field is mutated, or a channel is created, even if the user has not asked about concurrency. Does not cover context.Context patterns (see go-context).","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-concurrency to design or review this concurrent Go code.","display_name":"Go Concurrency","icon_large_url":null,"icon_small_url":null,"iconography":"hierarchy","short_description":"Design safe concurrent Go code"},"name":"go-concurrency","plugin_release_skill_id":"pluginrsk_6a7b1e4174f88191b4d788d19b571609"},{"description":"Use when designing, propagating, or debugging context.Context flow in Go — first-parameter placement, deadlines and cancellation, request-scoped values, WithoutCancel for fire-and-forget work, and key-collision-safe value patterns. Apply proactively whenever a function takes ctx, spawns work, or accepts request-scoped data, even if the user has not asked about context.","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-context to review context propagation, deadlines, and cancellation in this Go code.","display_name":"Go Context","icon_large_url":null,"icon_small_url":null,"iconography":"code","short_description":"Handle Go context flow and cancellation"},"name":"go-context","plugin_release_skill_id":"pluginrsk_6a7b1e44ce208191926a0e0a85169b2e"},{"description":"Use when writing conditionals, loops, switches, type switches, or blank-identifier patterns in Go. Covers if-with-initialization, guard clauses, early returns, the unified for loop, range over slices/maps/strings/channels, parallel assignment, labeled break, and `_` for discards and side-effect imports. Apply proactively to any new if/for/switch, even when the user does not mention scoping or shadowing. Does not cover error-flow specifics (see go-error-handling).","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-control-flow to simplify and review this Go control flow.","display_name":"Go Control Flow","icon_large_url":null,"icon_small_url":null,"iconography":"code","short_description":"Write clear Go branches, loops, and switches"},"name":"go-control-flow","plugin_release_skill_id":"pluginrsk_6a7b1e417e608191b84cc9ca8de6e643"},{"description":"Use when choosing or operating on Go slices, maps, arrays, strings, or container/* types — including slice internals, capacity growth, preallocation, map buckets, sets via map[T]struct{}, strings.Builder vs bytes.Buffer, generic containers, and the slices/maps standard packages (Go 1.21+). Apply proactively whenever data is being collected, transformed, or copied, even if the user has not asked about allocation.","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-data-structures to choose or optimize the data structures in this Go code.","display_name":"Go Data Structures","icon_large_url":null,"icon_small_url":null,"iconography":"code","short_description":"Choose efficient Go data structures"},"name":"go-data-structures","plugin_release_skill_id":"pluginrsk_6a7b1e409934819189f7903ca22b5714"},{"description":"Use when writing, reviewing, or debugging Go code that talks to a SQL database (PostgreSQL, MySQL, MariaDB, SQLite). Covers library choice (database/sql, sqlx, sqlc, pgx, GORM trade-offs), parameterized queries, context propagation, NULL handling, scanning, transactions and isolation, connection pool tuning, and migration tooling. Apply when adding repository code, refactoring SQL, or auditing for missing rows.Close()/QueryContext.","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-database to design or review this Go database code.","display_name":"Go Database","icon_large_url":null,"icon_small_url":null,"iconography":"code","short_description":"Build safe SQL access in Go"},"name":"go-database","plugin_release_skill_id":"pluginrsk_6a7b1e43e15c819181799f6e69103e29"},{"description":"Use when declaring or initializing Go variables, constants, structs, or maps. Covers var vs :=, grouped declaration blocks, iota enums starting at 1, struct/map/slice composite literals, raw string literals, `any` over `interface{}`, and avoiding shadowed builtins. Apply proactively to any new struct, const block, or top-level var, even if the user did not ask about declaration style. Does not cover identifier naming (see go-naming).","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-declarations to review these Go declarations and initializers.","display_name":"Go Declarations","icon_large_url":null,"icon_small_url":null,"iconography":"code","short_description":"Write clear Go declarations and initialization"},"name":"go-declarations","plugin_release_skill_id":"pluginrsk_6a7b1e4315348191b5683061a2254511"},{"description":"Use when hardening Go code at API boundaries: copy slices/maps on entry and return, defer cleanup, verify interface compliance at compile time, model time with time.Time/time.Duration, design enum zero values, prefer crypto/rand, and inject clocks for testability. Apply proactively when reviewing for robustness. Error-handling strategy: see go-error-handling.","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-defensive to harden this Go code at its API boundaries.","display_name":"Go Defensive Programming","icon_large_url":null,"icon_small_url":null,"iconography":"hierarchy","short_description":"Harden Go API boundaries and invariants"},"name":"go-defensive","plugin_release_skill_id":"pluginrsk_6a7b1e46c2548191b2f10b360a437a3f"},{"description":"Use when writing or reviewing Go documentation — godoc comments on packages, types, functions, methods, sentinel errors; runnable Example tests; README/CONTRIBUTING/CHANGELOG. Covers the project-type detection (library vs application) that decides which docs are needed, comment grammar (start with name, full sentences), what to document vs what to skip, and Example test conventions. Apply proactively when introducing exported names, even if documentation was not requested.","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-documentation to write or review documentation for this Go code.","display_name":"Go Documentation","icon_large_url":null,"icon_small_url":null,"iconography":"pen","short_description":"Write useful Go docs and examples"},"name":"go-documentation","plugin_release_skill_id":"pluginrsk_6a7b1e4261908191a29bce3355dea504"},{"description":"Use when writing, wrapping, inspecting, or logging Go errors. Covers strategy choice (sentinel vs typed vs opaque), wrapping with %w/%v, errors.Is/As/Join, the log-or-return rule, error strings, and panic/recover boundaries. Apply proactively whenever a function returns or accepts an error, even if the user has not asked about error handling.","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-error-handling to design or review error handling in this Go code.","display_name":"Go Error Handling","icon_large_url":null,"icon_small_url":null,"iconography":"code","short_description":"Design idiomatic Go error handling"},"name":"go-error-handling","plugin_release_skill_id":"pluginrsk_6a7b1e436e7881918ab86084b6559af5"},{"description":"Use when designing a Go constructor or factory with 3+ optional parameters, or an API expected to grow new options over time. Covers the canonical Option interface pattern with unexported apply method, With* constructors, default values, and the interface-vs-closure tradeoff. Apply proactively when reviewing a New* function that takes many settings, even if the user didn't ask about functional options. Does not cover general function design (see go-functions).","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-functional-options to design an extensible constructor for this Go API.","display_name":"Go Functional Options","icon_large_url":null,"icon_small_url":null,"iconography":"hierarchy","short_description":"Design extensible Go constructors"},"name":"go-functional-options","plugin_release_skill_id":"pluginrsk_6a7b1e4185e881918ed0b1cdbe23260d"},{"description":"Use when organising functions in a Go file, formatting signatures, designing return values, or naming Printf-style helpers. Covers in-file ordering (type → ctor → exported → unexported → utils), multi-line signature shape, naked-parameter clarity, pointer-vs-value receivers, and the `f`-suffix rule. Apply proactively to any new function. Functional options: see go-functional-options.","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-functions to design or review these Go functions.","display_name":"Go Function Design","icon_large_url":null,"icon_small_url":null,"iconography":"code","short_description":"Design focused and idiomatic Go functions"},"name":"go-functions","plugin_release_skill_id":"pluginrsk_6a7b1e4424448191baccc396ec0af620"},{"description":"Use when deciding whether to introduce Go generics, writing generic functions or types, composing type constraints, or choosing between type aliases and type definitions. Apply proactively when a user is writing a utility function that could conceivably work with multiple types, even if they didn't mention generics. Does not cover interface-only designs (see go-interfaces).","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-generics to decide whether and how to use generics in this Go code.","display_name":"Go Generics","icon_large_url":null,"icon_small_url":null,"iconography":"code","short_description":"Use Go generics with clear constraints"},"name":"go-generics","plugin_release_skill_id":"pluginrsk_6a7b1e450d6c8191ab0318b633c5a022"},{"description":"Use when building or reviewing a GraphQL API in Go. Covers library choice (gqlgen vs graph-gophers), schema design (nullability, pagination, mutation envelopes), thin resolver pattern, per-request DataLoaders for N+1, authentication via context plus schema directives, error presenters, subscription lifecycle (context cancellation), and production hardening (complexity limits, introspection gating). Apply when working with github.com/99designs/gqlgen or github.com/graph-gophers/graphql-go.","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-graphql to design or review this Go GraphQL API.","display_name":"Go GraphQL","icon_large_url":null,"icon_small_url":null,"iconography":"code","short_description":"Build production GraphQL APIs in Go"},"name":"go-graphql","plugin_release_skill_id":"pluginrsk_6a7b1e409ab081918b8fae4077e3b181"},{"description":"Use when implementing or reviewing gRPC servers/clients in Go. Covers .proto organisation, code generation with protoc/buf, server bootstrap (interceptors, health, graceful shutdown), client patterns (reuse, deadlines, retries), status.Code error handling, streaming, TLS/mTLS, and bufconn testing. Apply when writing .proto files, adding interceptors, or auditing a service for production readiness.","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-grpc to design or review this Go gRPC service.","display_name":"Go gRPC","icon_large_url":null,"icon_small_url":null,"iconography":"code","short_description":"Build production gRPC services in Go"},"name":"go-grpc","plugin_release_skill_id":"pluginrsk_6a7b1e44f3dc819199b78feeeee643f5"},{"description":"Use when defining or implementing Go interfaces, composing types through embedding, designing dependency-injection seams, or deciding between pointer and value receivers. Apply proactively whenever a new abstraction is introduced or a constructor returns an abstract type, even if the user has not asked about interfaces. Does not cover generics (see go-generics).","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-interfaces to design or review the interfaces in this Go code.","display_name":"Go Interfaces","icon_large_url":null,"icon_small_url":null,"iconography":"code","short_description":"Design small and useful Go interfaces"},"name":"go-interfaces","plugin_release_skill_id":"pluginrsk_6a7b1e44b47481919f9b6a4d746574f1"},{"description":"Use when setting up linting for a Go project, configuring golangci-lint, picking a linter set, suppressing findings with //nolint, or wiring lint checks into CI. Apply proactively whenever a project lacks .golangci.yml, when lint output is unclear, or when a new package needs the project's quality bar. Does not cover code review process (see go-code-review).","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-linting to configure or diagnose linting for this Go project.","display_name":"Go Linting","icon_large_url":null,"icon_small_url":null,"iconography":"hierarchy","short_description":"Configure practical Go lint checks"},"name":"go-linting","plugin_release_skill_id":"pluginrsk_6a7b1e4583088191a14a53d187c439fa"},{"description":"Use when choosing a Go logger, configuring slog, writing structured log statements, picking log levels, or attaching request-scoped fields. Apply proactively whenever code calls log/fmt to emit operational information, migrates off log/logrus/zap/zerolog, or sets up production logging. Covers structured logging only — metrics, traces, profiling, and RUM belong to a separate observability skill.","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-logging to design or review structured logging in this Go code.","display_name":"Go Logging","icon_large_url":null,"icon_small_url":null,"iconography":"hierarchy","short_description":"Implement structured logging in Go"},"name":"go-logging","plugin_release_skill_id":"pluginrsk_6a7b1e433fa08191a996ff8e7f0a6b1c"},{"description":"Use when naming any Go identifier — packages, types, functions, methods, receivers, variables, constants, errors, options. Covers MixedCaps, scope-based length, initialism casing, the no-`Get` rule, `-er` interfaces, sentinel `ErrX` vs typed `XError`, and the most commonly missed conventions (constructors, boolean fields, enum zero values, lowercase error strings). Apply proactively whenever new identifiers are introduced, even if the user has not asked about naming.","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-naming to review and improve names in this Go code.","display_name":"Go Naming","icon_large_url":null,"icon_small_url":null,"iconography":"code","short_description":"Choose idiomatic names for Go identifiers"},"name":"go-naming","plugin_release_skill_id":"pluginrsk_6a7b1e4759848191b3b22fe1cb17c795"},{"description":"Use when instrumenting Go services with metrics and distributed traces, or wiring exemplars and request-id propagation. Covers Prometheus patterns (Counter/Gauge/Histogram, low-cardinality labels), OpenTelemetry tracing (TracerProvider, span attributes, errors, context propagation), and metric ↔ trace correlation so a P99 spike jumps to the offending trace. Logging: see go-logging.","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-observability to instrument this Go service with useful metrics and traces.","display_name":"Go Observability","icon_large_url":null,"icon_small_url":null,"iconography":"radar","short_description":"Add metrics and traces to Go services"},"name":"go-observability","plugin_release_skill_id":"pluginrsk_6a7b1e43edb08191951cbc27285c95ac"},{"description":"Use when creating Go packages, organizing imports, managing dependencies, or structuring a Go project. Covers meaningful package names, package size, import grouping (stdlib first, then external), blank/dot imports, the run() pattern in main, init() restrictions, and CLI flag conventions. Apply proactively when starting a new module or splitting a growing codebase, even if the user did not explicitly ask about package layout. Does not cover identifier naming inside packages (see go-naming).","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-packages to design or review this Go package structure.","display_name":"Go Packages and Imports","icon_large_url":null,"icon_small_url":null,"iconography":"hierarchy","short_description":"Structure Go packages and imports clearly"},"name":"go-packages","plugin_release_skill_id":"pluginrsk_6a7b1e45c9448191ad9870b3db4a04eb"},{"description":"Use when profiling, benchmarking, or optimizing Go code — includes the measure-first methodology, the pprof-driven decision tree (which symptom maps to which fix), allocation reduction, capacity hints, hot-path patterns (strconv vs fmt, repeated string→byte conversions, strings.Builder), and runtime tuning. Apply proactively whenever a user mentions slowness, allocations, GC pressure, or asks for benchmarks, even if no specific pattern is named.","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-performance to measure and optimize this Go performance problem.","display_name":"Go Performance","icon_large_url":null,"icon_small_url":null,"iconography":"radar","short_description":"Profile and optimize Go code with evidence"},"name":"go-performance","plugin_release_skill_id":"pluginrsk_6a7b1e4285688191abec3ba59cec1843"},{"description":"Use when adding or maintaining OpenAPI/Swagger documentation for a Go HTTP API. Covers swaggo/swag annotation comments (@Summary, @Param, @Success, @Router, @Security), the swag CLI workflow, framework integration for Gin/Echo/Fiber/Chi/net-http, security definitions (Bearer/JWT, OAuth2, API key), and struct tags (example, enums, swaggertype, swaggerignore). Apply when a project imports github.com/swaggo/swag or any of the swaggo UI adapters, or when you need to expose /swagger/index.html.","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-swagger to add or review OpenAPI documentation for this Go API.","display_name":"Go Swagger and OpenAPI","icon_large_url":null,"icon_small_url":null,"iconography":"pdf","short_description":"Document Go APIs with Swagger and OpenAPI"},"name":"go-swagger","plugin_release_skill_id":"pluginrsk_6a7b1e4674508191a73837420114faf6"},{"description":"Use when writing or fixing Go tests — table-driven cases, parallel safety, helpers, fakes, fuzzing, deterministic time (testing/synctest), goroutine leak detection (goleak), HTTP handlers. Apply proactively when a function gets a new test or a test is flaky. Benchmark methodology: see go-benchmark.","interface":{"brand_color":"#00ADD8","default_prompt":"Use $go-testing to write or improve tests for this Go code.","display_name":"Go Testing","icon_large_url":null,"icon_small_url":null,"iconography":"code","short_description":"Write reliable and focused Go tests"},"name":"go-testing","plugin_release_skill_id":"pluginrsk_6a7b1e47df448191b043a17eae2b5a50"}],"version":"0.1.0"},"scope":"GLOBAL","status":"ENABLED"},"research":null,"package_metadata":{"name":"gophers","author":{"url":"https://github.com/muratmirgun","name":"muratmirgun"},"license":"MIT","sources":[{"path":".codex-plugin/plugin.json","sha256":"4a838e3c066d9935b22d0542ef64dcc3e2da1ccb4708749fa90e7047589709c1"}],"version":"0.1.0","homepage":"https://muratmirgun.github.io/gophers/","keywords":["go","golang","skills","code-review","testing","concurrency","observability"],"repository":"https://github.com/muratmirgun/gophers","artifact_id":16892,"observed_at":"2026-10-03T06:31:42Z","capabilities":["Read","Write"],"field_sources":{"name":0,"author":0,"license":0,"version":0,"homepage":0,"keywords":0,"repository":0,"capabilities":0},"extraction_version":1,"conflicts_or_errors":[]}}