cxuu/golang-skills

go-linting

Use when setting up linting for a Go project, configuring golangci-lint, or adding Go checks to a CI/CD pipeline.

View source

How to use

  1. Copy the installation command and review the source package before installing it in your own agent environment.
  2. Check the source document for required tools, credentials and supported hosts.
  3. Describe your input and desired deliverable; review the output against the source material.
npx skills add https://github.com/cxuu/golang-skills --skill go-linting

Before you start

  • Installation does not include a model subscription, API allowance or permission to access your files.
  • Repository stars and installation counts describe activity, not an independent quality or security test.
Original skill document

Rendered from the source repository. Headings, examples, code, tables, links, and referenced images are preserved.

Go Linting

Core Principle

More important than any "blessed" set of linters: lint consistently across a codebase.

Consistent linting helps catch common issues and establishes a high bar for code quality without being unnecessarily prescriptive.

Resource Routing

  • scripts/setup-lint.sh - Run when generating a .golangci.yml, validating the first lint pass, or producing JSON metadata.
  • assets/golangci.yml - Use as the v2 golangci-lint baseline for established projects.

Setup Procedure

  1. Create .golangci.yml with scripts/setup-lint.sh or copy assets/golangci.yml
  2. Run golangci-lint run ./...
  3. If errors appear, fix them category by category (formatting first, then vet, then style)
  4. Re-run until clean

After generating .golangci.yml, run golangci-lint config verify --config .golangci.yml to verify the configuration schema before relying on lint results.


Minimum Recommended Linters

These linters catch the most common issues while maintaining a high quality bar:

LinterPurpose
errcheckEnsure errors are handled
goimportsFormat code and manage imports
reviveCommon style mistakes (modern replacement for golint)
govetAnalyze code for common mistakes
staticcheckVarious static analysis checks
Note: revive is the modern, faster successor to the now-deprecated golint.

Lint Runner: golangci-lint

Use golangci-lint as your lint runner. See the example .golangci.yml from uber-go/guide.


Example Configuration

Use assets/golangci.yml as the maintained example. It targets golangci-lint v2 (verified with 2.10.1 on 2026-06-19), keeps goimports under formatters, and enables the core linters plus common production additions.

Running

bash
# Install the version this skill's config is verified against
go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.10.1

# Run all linters
golangci-lint run

# Run on specific paths
golangci-lint run ./pkg/...

Additional Recommended Linters

Beyond the minimum set, consider these for production projects:

LinterPurposeWhen to enable
gosecSecurity vulnerability detectionAlways for services handling user input
ineffassignDetect ineffectual assignmentsAlways — catches dead code
misspellCorrect common misspellings in comments/stringsAlways
gocycloCyclomatic complexity thresholdWhen functions exceed ~15 complexity
exhaustiveEnsure switch covers all enum valuesWhen using iota enums
bodycloseDetect unclosed HTTP response bodiesAlways for HTTP client code

Nolint Directives

When suppressing a lint finding, always explain why:

go
//nolint:errcheck // fire-and-forget logging; error is not actionable
_ = logger.Sync()

Rules:

  • Use //nolint:lintername — never bare //nolint
  • Place the comment on the same line as the finding
  • Include a justification after //

CI/CD Integration

Run golangci-lint run ./... in CI after tests. Pin the golangci-lint version used by CI so local and release behavior do not drift.

Pre-commit Hook

bash
#!/bin/sh
# .git/hooks/pre-commit
golangci-lint run --new-from-rev=HEAD~1

Use --new-from-rev to lint only changed code, keeping the feedback loop fast.


Quick Reference

TaskCommand/Action
Install golangci-lintgo install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.10.1
Run lintersgolangci-lint run
Run on pathgolangci-lint run ./pkg/...
Config file.golangci.yml in project root
CI integrationRun golangci-lint run in pipeline
Nolint directives//nolint:name // reason — never bare //nolint
CI integrationUse golangci/golangci-lint-action for GitHub Actions
Pre-commitgolangci-lint run --new-from-rev=HEAD~1

Linter Selection Guidelines

When you need...Use
Error handling coverageerrcheck
Import formattinggoimports
Style consistencyrevive
Bug detectiongovet, staticcheck
All of the abovegolangci-lint with config

Related Skills

  • Style foundations: See go-style-core when resolving style questions that linters enforce (formatting, nesting, naming)
  • Code review: See go-code-review when combining linter output with a manual review checklist
  • Error handling: See go-error-handling when errcheck flags unhandled errors and you need to decide how to handle them
  • Testing: See go-testing when running linters alongside tests in CI pipelines
from this repository

More skills

All skills
cxuu
Community

go-code-review

Use when reviewing Go code or checking code against community style standards. Also use proactively before submitting a Go PR or when reviewing any Go code changes, even if the user doesn't explicitly request a style review. Does not cover language-specific syntax — delegates to specialized skills.

1h installs
2
GitHub stars
189
Updated
Jun 20
cxuu
Community

go-concurrency

Use when writing concurrent Go code — goroutines, channels, mutexes, or thread-safety guarantees. Also use when parallelizing work, fixing data races, or protecting shared state, even if the user doesn't explicitly mention concurrency primitives. Does not cover context.Context patterns (see go-context).

1h installs
2
GitHub stars
189
Updated
Jun 20
cxuu
Community

go-context

Use when working with context.Context in Go — placement in signatures, propagating cancellation and deadlines, and storing values in context vs parameters. Also use when cancelling long-running operations, setting timeouts, or passing request-scoped data, even if they don't mention context.Context directly. Does not cover goroutine lifecycle or sync primitives (see go-concurrency).

1h installs
2
GitHub stars
189
Updated
Jun 20
cxuu
Community

go-control-flow

Use when writing conditionals, loops, or switch statements in Go — including if with initialization, early returns, for loop forms, range, switch, type switches, and blank identifier patterns. Also use when writing a simple if/else or for loop, even if the user doesn't mention guard clauses or variable scoping. Does not cover error flow patterns (see go-error-handling).

1h installs
2
GitHub stars
189
Updated
Jun 20