Skip to main content
skill CX Codex

go-linting — Claude Code skill for Go linting and setup

The go-linting skill for Claude Code configures golangci-lint, helps select checks for a Go codebase, and adds linting to CI for new or existing projects.

Apache-2.0 1,400 installs ★ 196 updated 2026-06-20

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add cxuu/golang-skills --skill go-linting -a claude-code
Open on GitHub

What go-linting does

The skill walks through creating .golangci.yml with scripts/setup-lint.sh or starting from assets/golangci.yml, then running golangci-lint run ./.... It suggests fixing findings by category: formatting first, followed by vet checks and style. Verify a generated config with golangci-lint config verify --config .golangci.yml before relying on its results.

Its baseline includes errcheck, goimports, revive, govet, and staticcheck. It also describes extra checks, such as gosec for services that process user input and bodyclose for HTTP client code. For CI, the skill recommends running lint after tests and pinning the golangci-lint version; otherwise local and release runs can differ.

The sample configuration targets golangci-lint v2, and its install command pins v2.10.1. When suppressing a finding, name the linter and explain the reason in a //nolint comment. Bare //nolint directives are disallowed.

What it helps with

  • create a .golangci.yml for a Go project
  • choose linters for error and style checks
  • add linting to a CI pipeline
  • limit a pre-commit run to changed code
  • document why a lint finding is suppressed

Example prompts for the agent

  • Set up linting for this Go project and create .golangci.yml.
  • Add golangci-lint run ./... to CI after the tests.
  • Check the config with golangci-lint config verify --config .golangci.yml.

How to install go-linting

1Skills CLI (Vercel)

npx skills add cxuu/golang-skills --skill go-linting -a claude-code

2Manually: put the files in place

~/.claude/skills/go-linting/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/go-linting/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about go-linting

How do I install go-linting in Claude Code?

Run npx skills add cxuu/golang-skills --skill go-linting -a claude-code. The skill file is at ~/.claude/skills/go-linting/SKILL.md.

What does go-linting do?

It guides setup for golangci-lint, recommends checks for Go projects, and covers CI and pre-commit use.

Which golangci-lint version does the sample config target?

The assets/golangci.yml example targets golangci-lint v2. The installation command uses version v2.10.1.

Source text

SKILL.md · Apache-2.0
---
name: go-linting
description: Use when setting up linting for a Go project, configuring golangci-lint, or adding Go checks to a CI/CD pipeline. Also use when starting a new Go project and deciding which linters to enable, even if the user only asks about "code quality" or "static analysis" without mentioning specific linter names. Does not cover code review process (see go-code-review).
allowed-tools: Bash(bash:*)
---

# 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:

| Linter | Purpose |
|--------|---------|
| [errcheck](https://github.com/kisielk/errcheck) | Ensure errors are handled |
| [goimports](https://pkg.go.dev/golang.org/x/tools/cmd/goimports) | Format code and manage imports |
| [revive](https://github.com/mgechev/revive) | Common style mistakes (modern replacement for golint) |
| [govet](https://pkg.go.dev/cmd/vet) | Analyze code for common mistakes |
| [staticcheck](https://staticcheck.dev) | Various static analysis checks |

> **Note**: `revive` is the modern, faster successor to the now-deprecated `golint`.

---

## Lint Runner: golangci-lint

Use [golangci-lint](https://github.com/golangci/golangci-lint) as your lint runner. See the [example .golangci.yml](https://github.com/uber-go/guide/blob/master/.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/[email protected]

# 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:

| Linter | Purpose | When to enable |
|--------|---------|----------------|
| [gosec](https://github.com/securego/gosec) | Security vulnerability detection | Always for services handling user input |
| [ineffassign](https://github.com/gordonklaus/ineffassign) | Detect ineffectual assignments | Always — catches dead code |
| [misspell](https://github.com/client9/misspell) | Correct common misspellings in comments/strings | Always |
| [gocyclo](https://github.com/fzipp/gocyclo) | Cyclomatic complexity threshold | When functions exceed ~15 complexity |
| [exhaustive](https://github.com/nishanths/exhaustive) | Ensure switch covers all enum values | When using iota enums |
| [bodyclose](https://github.com/timakin/bodyclose) | Detect unclosed HTTP response bodies | Always 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

| Task | Command/Action |
|------|----------------|
| Install golangci-lint | `go install github.com/golangci/golangci-lint/v2/cmd/[email protected]` |
| Run linters | `golangci-lint run` |
| Run on path | `golangci-lint run ./pkg/...` |
| Config file | `.golangci.yml` in project root |
| CI integration | Run `golangci-lint run` in pipeline |
| Nolint directives | `//nolint:name // reason` — never bare `//nolint` |
| CI integration | Use `golangci/golangci-lint-action` for GitHub Actions |
| Pre-commit | `golangci-lint run --new-from-rev=HEAD~1` |

### Linter Selection Guidelines

| When you need... | Use |
|------------------|-----|
| Error handling coverage | errcheck |
| Import formatting | goimports |
| Style consistency | revive |
| Bug detection | govet, staticcheck |
| All of the above | golangci-lint with config |

---

## Related Skills

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

© cxuu · Apache-2.0 · cxuu/golang-skills

Similar skills

All skills for Programming languages →

From the same set20

The whole set →
go-interfaces go-interfaces guides coding agents through Go interface design, type composition, and compile-time checks. Prevents premature abstractions in public APIs. CX Codex +1 1,400installs go-documentation go-documentation writes and reviews doc comments for exported Go packages, types and functions. Also fires on its own when you add a new exported API. CX Codex +1 1,400installs go-concurrency go-concurrency is a Claude Code skill that sets rules for goroutines, channels and mutexes to prevent leaks and data races in Go code. CX Codex +1 1,400installs go-error-handling Guides coding agents on idiomatic Go error handling, covering sentinel errors, error wrapping with %w or %v, and clean error flow. CX Codex +1 1,400installs go-control-flow Teaches AI agents canonical Go control flow patterns: early returns, scoped if statements, and for loops. Keeps code flat and avoids variable shadowing bugs. CX Codex +1 1,300installs go-functional-options go-functional-options — a skill that walks you through functional options for Go constructors with optional settings. Useful once a New* function takes three or more optional parameters. CX Codex +1 1,300installs go-data-structures go-data-structures is a Claude Code skill that guides Go slice, map and array use. It fires when building collections, choosing between nil and a literal, or implementing sets. CX Codex +1 1,300installs go-packages Enforces Go package structuring, import grouping, and main entry point design. Useful when starting a new Go project or splitting a growing codebase. CX Codex +1 1,300installs

Project sponsors

Companies that keep this analytics open