All authors
Claude Skills by muratmirgun
github.com/muratmirgun52 skills0 installs83 views
- Go Clean ArchitectureUse 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.Votes: 0GitHub stars: 8
- Go Code ReviewInvoke 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.Votes: 0GitHub stars: 8
- Go Code StyleUse 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.Votes: 0GitHub stars: 8
- Go ConcurrencyUse 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).Votes: 0GitHub stars: 8
- Go ContextUse 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.Votes: 0GitHub stars: 8
- Go Control FlowUse 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).Votes: 0GitHub stars: 8
- Go Data StructuresUse 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.Votes: 0GitHub stars: 8
- Go DatabaseUse 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.Votes: 0GitHub stars: 8
- Go DeclarationsUse 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).Votes: 0GitHub stars: 8
- Go DefensiveUse 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.Votes: 0GitHub stars: 8
- Go DocumentationUse 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.Votes: 0GitHub stars: 8
- Go Error HandlingUse 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.Votes: 0GitHub stars: 8
- Go Functional OptionsUse 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).Votes: 0GitHub stars: 8
- Go FunctionsUse 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.Votes: 0GitHub stars: 8
- Go GenericsUse 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).Votes: 0GitHub stars: 8
- Go GraphqlUse 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.Votes: 0GitHub stars: 8
- Go GrpcUse 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.Votes: 0GitHub stars: 8
- Go InterfacesUse 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).Votes: 0GitHub stars: 8
- Go LintingUse 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).Votes: 0GitHub stars: 8
- Go LoggingUse 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.Votes: 0GitHub stars: 8
- Go NamingUse 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.Votes: 0GitHub stars: 8
- Go ObservabilityUse 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.Votes: 0GitHub stars: 8
- Go PackagesUse 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).Votes: 0GitHub stars: 8
- Go PerformanceUse 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.Votes: 0GitHub stars: 8
- Go SwaggerUse 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.Votes: 0GitHub stars: 8
- Go TestingUse 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.Votes: 0GitHub stars: 8
- Go Clean Architecture'Use when scaffolding or refactoring a Go service into a framework-agnosticVotes: 0GitHub stars: 8
- Go Code ReviewInvoke this skill to systematically review a Go change against communityVotes: 0GitHub stars: 8
- Go Code StyleUse when writing or reviewing Go code for clarity, formatting, controlVotes: 0GitHub stars: 8
- Go ConcurrencyUse when writing or reviewing concurrent Go code — goroutines, channels,Votes: 0GitHub stars: 8
- Go ContextUse when designing, propagating, or debugging context.Context flow inVotes: 0GitHub stars: 8
- Go Control FlowUse when writing conditionals, loops, switches, type switches, or blank-identifierVotes: 0GitHub stars: 8
- Go Data StructuresUse when choosing or operating on Go slices, maps, arrays, strings, orVotes: 0GitHub stars: 8
- Go DatabaseUse when writing, reviewing, or debugging Go code that talks to a SQLVotes: 0GitHub stars: 8
- Go DeclarationsUse when declaring or initializing Go variables, constants, structs,Votes: 0GitHub stars: 8
- Go Defensive'Use when hardening Go code at API boundaries: copy slices/maps on entryVotes: 0GitHub stars: 8
- Go DocumentationUse when writing or reviewing Go documentation — godoc comments on packages,Votes: 0GitHub stars: 8
- Go Error HandlingUse when writing, wrapping, inspecting, or logging Go errors. CoversVotes: 0GitHub stars: 8
- Go Functional OptionsUse when designing a Go constructor or factory with 3+ optional parameters,Votes: 0GitHub stars: 8
- Go Functions'Use when organising functions in a Go file, formatting signatures, designingVotes: 0GitHub stars: 8
- Go GenericsUse when deciding whether to introduce Go generics, writing generic functionsVotes: 0GitHub stars: 8
- Go GraphqlUse when building or reviewing a GraphQL API in Go. Covers library choiceVotes: 0GitHub stars: 8
- Go GrpcUse when implementing or reviewing gRPC servers/clients in Go. CoversVotes: 0GitHub stars: 8
- Go InterfacesUse when defining or implementing Go interfaces, composing types throughVotes: 0GitHub stars: 8
- Go LintingUse when setting up linting for a Go project, configuring golangci-lint,Votes: 0GitHub stars: 8
- Go LoggingUse when choosing a Go logger, configuring slog, writing structured logVotes: 0GitHub stars: 8
- Go NamingUse when naming any Go identifier — packages, types, functions, methods,Votes: 0GitHub stars: 8
- Go Observability'Use when instrumenting Go services with metrics and distributed traces,Votes: 0GitHub stars: 8
- Go PackagesUse when creating Go packages, organizing imports, managing dependencies,Votes: 0GitHub stars: 8
- Go PerformanceUse when profiling, benchmarking, or optimizing Go code — includes theVotes: 0GitHub stars: 8