Golang Continuous Integration
context-labs/whip
CI/CD with GitHub Actions for Golang — testing, linting, SAST, security scanning, coverage, Dependabot, Renovate, GoReleaser, release pipelines.
GitHub Actions CI/CD pipeline configuration for Golang projects — workflow files for test, lint, SAST, coverage and vulnerability-scan jobs, Dependabot and Renovate config files, GoReleaser release…
$ npx skills add samber/cc-skills-golang --skill golang-continuous-integration -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install samber/cc-skills-golang golang-continuous-integration --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/samber/cc-skills-golang.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/golang-continuous-integration .claude/skills/golang-continuous-integration && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "golang-continuous-integration" agent skill from https://github.com/samber/cc-skills-golang/tree/main/skills/golang-continuous-integration into .claude/skills/golang-continuous-integration/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "golang-continuous-integration", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/samber/cc-skills-golang/tree/main/skills/golang-continuous-integrationType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add samber/cc-skills-golang --skill golang-continuous-integration -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install samber/cc-skills-golang golang-continuous-integration --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/samber/cc-skills-golang.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/golang-continuous-integration .agents/skills/golang-continuous-integration && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "golang-continuous-integration" agent skill from https://github.com/samber/cc-skills-golang/tree/main/skills/golang-continuous-integration into .agents/skills/golang-continuous-integration/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "golang-continuous-integration", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add samber/cc-skills-golang --skill golang-continuous-integration -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install samber/cc-skills-golang golang-continuous-integration --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/samber/cc-skills-golang.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/golang-continuous-integration .cursor/skills/golang-continuous-integration && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "golang-continuous-integration" agent skill from https://github.com/samber/cc-skills-golang/tree/main/skills/golang-continuous-integration into .cursor/skills/golang-continuous-integration/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "golang-continuous-integration", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/samber/cc-skills-golang.git --path skills/golang-continuous-integration--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add samber/cc-skills-golang --skill golang-continuous-integration -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install samber/cc-skills-golang golang-continuous-integration --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/samber/cc-skills-golang.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/golang-continuous-integration .gemini/skills/golang-continuous-integration && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "golang-continuous-integration" agent skill from https://github.com/samber/cc-skills-golang/tree/main/skills/golang-continuous-integration into .gemini/skills/golang-continuous-integration/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "golang-continuous-integration", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install samber/cc-skills-golang golang-continuous-integrationInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add samber/cc-skills-golang --skill golang-continuous-integration -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/samber/cc-skills-golang.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/golang-continuous-integration .github/skills/golang-continuous-integration && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "golang-continuous-integration" agent skill from https://github.com/samber/cc-skills-golang/tree/main/skills/golang-continuous-integration into .github/skills/golang-continuous-integration/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "golang-continuous-integration", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add samber/cc-skills-golang --skill golang-continuous-integration -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install samber/cc-skills-golang golang-continuous-integration --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/samber/cc-skills-golang.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/golang-continuous-integration .opencode/skills/golang-continuous-integration && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "golang-continuous-integration" agent skill from https://github.com/samber/cc-skills-golang/tree/main/skills/golang-continuous-integration into .opencode/skills/golang-continuous-integration/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "golang-continuous-integration", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
golang-continuous-integrationGitHub Actions CI/CD pipeline configuration for Golang projects — workflow files for test, lint, SAST, coverage and vulnerability-scan jobs, Dependabot and Renovate config files, GoReleaser release…
Golang Continuous Integration is an agent skill from samber/cc-skills-golang. GitHub Actions CI/CD pipeline configuration for Golang projects — workflow files for test, lint, SAST, coverage and vulnerability-scan jobs, Dependabot and Renovate config files, GoReleaser release pipelines, Docker build/push, repository security settings, and AI-driven PR review. Use when setting up or improving Go project CI, writing or fixing .github/workflows/.yml, adding a linter or security scanner as a pipeline job, wiring automated dependency-update bots, or adding quality gates. Covers wiring tools into…
Its SKILL.md is about 3.7k tokens, which your agent loads only when the skill is triggered. The skill folder holds 21 other files, including reference files and assets (for example `assets/claude-code-review.yml`, `assets/codecov.yml` and `assets/codeql-config.yml`). Compatibility notes: Designed for Claude Code, Codex or similar harness, and for projects using Golang.
It sits in Development, covering Dependency management, CI/CD and Linting and formatting. It works with Go, GitHub Actions and Docker. The repository describes itself as: 🧑🎨 A collection of Golang agentic skills that works. The licence is MIT.
Read from SKILL.md and the folder at commit 8e899e2. It shows what the files ask for, not the result of running them.
Pre-approves these tools, so the agent can use them without asking each time:
ReadEditWriteGlobGrepBash(go:*)Bash(golangci-lint:*)Bash(git:*)AgentWebFetch…and 3 more on the same allowed-tools line.
From allowed-tools in the SKILL.md frontmatter.
Shell commands in SKILL.md call:
gogitnpxbrewghFrom the folder's file list and the shell code blocks in SKILL.md.
Links to these hosts (documentation or services it may open):
github.comFrom URLs in SKILL.md, links to its own repository left out.
Names these keys or tokens, usually read from environment variables:
DOCKERHUB_TOKENGITHUB_TOKENFrom names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Designed for Claude Code, Codex or similar harness, and for projects using Golang.
From compatibility in the SKILL.md frontmatter.
Golang Continuous Integration loads about 3.7k tokens when it runs, and up to ~4.7k if it reads all its reference files. Until then it costs about 210 tokens; SKILL.md has 1,440 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.
The full file from samber/cc-skills-golang at commit 8e899e2, republished under its MIT licence (© samber). 1,440 words, ~3,682 tokens.
.claude/skills/golang-continuous-integration/SKILL.md (or your agent's skills folder). This skill also uses 19 other files; get the full folder from GitHub.Persona: You are a Go DevOps engineer. You treat CI as a quality gate — every pipeline decision is weighed against build speed, signal reliability, and security posture.
Modes:
Dependencies:
go install github.com/goreleaser/goreleaser/v2@latestbrew install ghSet up production-grade CI/CD pipelines for Go projects using GitHub Actions.
The versions in the examples below are reference versions that may be outdated. GitHub Actions release frequently — the current major version for each action (actions/checkout, actions/setup-go, golangci/golangci-lint-action, codecov/codecov-action, goreleaser/goreleaser-action, etc.) may differ from what is shown here.
| Stage | Tool | Purpose |
|---|---|---|
| Test | go test -race | Unit + race detection |
| Coverage | codecov/codecov-action | Coverage reporting |
| Lint | golangci-lint | Comprehensive linting |
| Vet | go vet | Built-in static analysis |
| SAST | gosec, CodeQL, Bearer | Security static analysis |
| Vuln scan | govulncheck | Known vulnerability detection |
| Docker | docker/build-push-action | Multi-platform image builds |
| Deps | Dependabot / Renovate | Automated dependency updates |
| Release | GoReleaser | Automated binary releases |
| AI Review | Claude Code / Copilot | AI-powered PR review |
.github/workflows/test.yml — see test.yml
Adapt the Go version matrix to match go.mod:
go 1.23 → matrix: ["1.23", "1.24", "1.25", "1.26", "1.27", "stable"]
go 1.24 → matrix: ["1.24", "1.25", "1.26", "1.27", "stable"]
go 1.25 → matrix: ["1.25", "1.26", "1.27", "stable"]
go 1.26 → matrix: ["1.26", "1.27", "stable"]
go 1.27 → matrix: ["1.27", "stable"]Use fail-fast: false so a failure on one Go version doesn't cancel the others.
Go 1.27 raises the Darwin floor to macOS 13 (Ventura). macos-latest/macos-14+ runners are unaffected; only pin an older macos-12 runner if a project still needs it, and note it can no longer build with a Go 1.27 toolchain.
Test flags:
-race: CI MUST run tests with the -race flag (catches data races — undefined behavior in Go)-shuffle=on: Randomize test order to catch inter-test dependencies-coverprofile: Generate coverage datagit diff --exit-code: Fails if go mod tidy changes anythingCI SHOULD enforce code coverage thresholds. Configure thresholds in codecov.yml at the repo root — see codecov.yml
.github/workflows/integration.yml — see integration.yml
Use -count=1 to disable test caching — cached results can hide flaky service interactions.
golangci-lint MUST be run in CI on every PR. .github/workflows/lint.yml — see lint.yml
Create .golangci.yml at the root of the project. See the samber/cc-skills-golang@golang-lint skill for the recommended configuration.
.github/workflows/security.yml — see security.yml
CI MUST run govulncheck — it only reports vulnerabilities in code paths your project actually calls, unlike generic CVE scanners.
Create .github/codeql/codeql-config.yml to use the extended security query suite — see codeql-config.yml
Available query suites:
If the project produces Docker images, Trivy container scanning is included in the Docker workflow — see docker.yml
.github/dependabot.yml — see dependabot.yml
Minor/patch updates are grouped into a single PR. Major updates get individual PRs since they may have breaking changes.
.github/workflows/dependabot-auto-merge.yml — see dependabot-auto-merge.yml
Security warning: This workflow requires
contents: writeandpull-requests: write— these are elevated permissions that allow merging PRs and modifying repository content. Theif: github.actor == 'dependabot[bot]'guard restricts execution to Dependabot only. Do not remove this guard. Note thatgithub.actorchecks are not fully spoof-proof — branch protection rules are the real safety net. Ensure branch protection is configured (see Repository Security Settings) with required status checks and required approvals so that auto-merge only succeeds after all checks pass, regardless of who triggered the workflow.
Renovate is a more mature and configurable alternative to Dependabot. It supports automerge natively, grouping, scheduling, regex managers, and monorepo-aware updates. If Dependabot feels too limited, Renovate is the go-to choice.
Install the Renovate GitHub App, then create renovate.json at the repo root — see renovate.json
Key advantages over Dependabot:
gomodTidy: Automatically runs go mod tidy after updatesGoReleaser automates binary builds, checksums, and GitHub Releases. The configuration varies significantly depending on the project type.
.github/workflows/release.yml — see release.yml
Security warning: This workflow requires
contents: writeto create GitHub Releases. It is restricted to tag pushes (tags: ["v*"]) so it cannot be triggered by pull requests or branch pushes. Only users with push access to the repository can create tags.
Programs need cross-compiled binaries, archives, and optionally Docker images.
.goreleaser.yml — see goreleaser-cli.yml
Libraries don't produce binaries — they only need a GitHub Release with a changelog. Use a minimal config that skips the build.
.goreleaser.yml — see goreleaser-lib.yml
For libraries, you may not even need GoReleaser — a simple GitHub Release created via the UI or gh release create is often sufficient.
When a repository contains multiple commands (e.g., cmd/api/, cmd/worker/).
.goreleaser.yml — see goreleaser-monorepo.yml
For projects that produce Docker images. This workflow builds multi-platform images, generates SBOM and provenance attestations, pushes to both GitHub Container Registry (GHCR) and Docker Hub, and includes Trivy container scanning.
.github/workflows/docker.yml — see docker.yml
Security warning: Permissions are scoped per job: the
container-scanjob only getscontents: read+security-events: write, while thedockerjob getspackages: write(to push to GHCR) andattestations: write+id-token: write(for provenance/SBOM signing). This ensures the scan job cannot push images even if compromised. Thepushflag is set tofalseon pull requests so untrusted code cannot publish images. TheDOCKERHUB_USERNAMEandDOCKERHUB_TOKENsecrets must be configured in the repository secrets settings — never hardcode credentials.
Key details:
linux/amd64,linux/arm64). Remove platforms you don't need.push: false on PRs: Images are built but never pushed on pull requests — this validates the Dockerfile without publishing untrusted code.v1.2.3 → 1.2.3, 1.2, 1), branch tags (main), and SHA tags.provenance: mode=max and sbom: true generate supply chain attestations. These require attestations: write and id-token: write permissions.GITHUB_TOKEN, no extra secret needed) and Docker Hub (requires DOCKERHUB_USERNAME + DOCKERHUB_TOKEN secrets). Remove the Docker Hub login and image line if not needed.docker.io/ line from images:.Repository security settings (branch protection, workflow permissions, secrets, environments) form the security foundation for the CI pipeline — these are documented in repo-security.md.
Add AI agents as PR reviewers alongside traditional static analysis. When loaded with this skill plugin, the agent applies the relevant Go skills per review area — catching architectural drift, logic bugs, missing error context, and concurrency hazards that linters cannot detect.
Cost note: AI review agents run concurrently per PR. For cost control, remove jobs you don't need or raise the PR trigger filter to specific branches only.
Each subsection below is a generated artifact targeting one specific reviewer — the linked asset file runs on a CI runner, not the developer's local harness, so its tool names and permission flags are deliberately literal rather than capability prose.
.github/workflows/ai-review.yml — see claude-code-review.yml
The workflow runs parallel jobs, each scoped to a set of review areas and priority level:
| Job | Areas | Priority |
|---|---|---|
quality | Code style, Naming, Documentation, Design patterns | Suggestion-first |
correctness | Error handling, Code safety, Concurrency | Blocking-first |
security | Security, Dependencies | Blocking-first |
quality-depth | Tests, Performance, Observability, Modernize | Mixed |
Additional skills that may be relevant depending on the project: golang-cli, golang-context, golang-data-structures, golang-database, golang-dependency-injection, or any library-specific skill.
The Claude Code GitHub App integration is configured via the /install-github-app command, which sets up the required API secrets.
Copy skills into your repo, then append copilot-review-instructions.md to .github/copilot-instructions.md:
npx skills add https://github.com/samber/cc-skills-golang --agent github-copilot --skill '*' -y --copy
ln -s .agents .copilot| Mistake | Fix |
|---|---|
Missing -race in CI tests | Always use go test -race |
No -shuffle=on | Randomize test order to catch inter-test dependencies |
| Caching integration test results | Use -count=1 to disable caching |
go mod tidy not checked | Add go mod tidy && git diff --exit-code step |
Missing fail-fast: false | One Go version failing shouldn't cancel other jobs |
| Not pinning action versions | GitHub Actions MUST use pinned major versions (e.g. @vN, not @master) |
No permissions block | Follow least-privilege per job |
| Ignoring govulncheck findings | Fix or suppress with justification |
| No AI review in CI | Add Claude Code or Copilot review — catches logic, security, and architectural issues that static analysis misses |
See samber/cc-skills-golang@golang-lint, samber/cc-skills-golang@golang-security, samber/cc-skills-golang@golang-testing, samber/cc-skills-golang@golang-dependency-management, samber/cc-skills-golang@golang-modernize skills.
© samber, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
SKILL.md and 19 other files (references, assets) in skills/golang-continuous-integration of samber/cc-skills-golang.
Open the folder on GitHubat commit 8e899e2
Golang Continuous Integration next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Golang Continuous Integration this skillsamber/cc-skills-golang | 3.4k | — | ~3.7k | Automated safety check: Pass | MIT | |
| Golang Continuous Integrationcontext-labs/whip | 1.1k | — | ~3.5k | Automated safety check: Pass | MIT | |
| ReviewdogAgentSecOps/SecOpsAgentKit | 220 | 1 repos | ~3k | Automated safety check: Pass | Custom licence | |
| Sicurezza GitHubccplugins/awesome-claude-code-plugins | 970 | — | ~486 | Automated safety check: Notes | Apache-2.0 | |
| Megalinter Checknvuillam/npm-groovy-lint | 248 | 1 repos | ~3.9k | Automated safety check: Notes | MIT | |
| Kubelb Dependency Updateskubermatic/kubelb | 148 | — | ~1.3k | Automated safety check: Pass | Apache-2.0 |
context-labs/whip
CI/CD with GitHub Actions for Golang — testing, linting, SAST, security scanning, coverage, Dependabot, Renovate, GoReleaser, release pipelines.
AgentSecOps/SecOpsAgentKit
Automated code review and security linting integration for CI/CD pipelines using reviewdog.
ccplugins/awesome-claude-code-plugins
Aggiunge alle repository GitHub dei siti workflow di sicurezza automatici - scansione dipendenze vulnerabili, ricerca di segreti/chiavi nel codice, analisi statica CodeQL e Dependabot.
nvuillam/npm-groovy-lint
Collect MegaLinter lint errors for the current repository. An agent skill from nvuillam/npm-groovy-lint.
kubermatic/kubelb
Sweep and update every dependency surface in the kubelb repo (go.mod, Makefile tool versions, prow images, GitHub Actions, hack/ci pins, addon Helm charts, pinned container images) and split the…
gocronx-team/gocron
Review, apply, verify, or merge gocron dependency updates from Dependabot or manual requests.
samber/cc-skills-golang
Comprehensive guide for dependency injection (DI) in Golang.
samber/cc-skills-golang
Dependency management for Golang projects — go.mod and go.sum, go get install and upgrade flows, Minimal Version Selection, conflict resolution with replace/exclude/retract, govulncheck scanning of…
samber/cc-skills-golang
Troubleshoot Golang programs systematically - find and fix the root cause.
samber/cc-skills-golang
In-memory caching in Golang using samber/hot — eviction algorithms (LRU, LFU, TinyLFU, W-TinyLFU, S3FIFO, ARC, TwoQueue, SIEVE, FIFO), TTL, cache loaders, sharding, stale-while-revalidate, missing…
samber/cc-skills-golang
Monadic types for Golang using samber/mo — Option, Result, Either, Future, IO, Task, and State types for type-safe nullable values, error handling, and functional composition with pipeline…
Works with
Categories
GitHub Actions CI/CD pipeline configuration for Golang projects — workflow files for test, lint, SAST, coverage and vulnerability-scan jobs, Dependabot and Renovate config files, GoReleaser release…. Golang Continuous Integration is an agent skill from samber/cc-skills-golang. GitHub Actions CI/CD pipeline configuration for Golang projects — workflow files for test, lint, SAST, coverage and vulnerability-scan jobs, Dependabot and Renovate config files, GoReleaser release pipelines, Docker build/push, repository security settings, and AI-driven PR review.
Golang Continuous Integration fits situations like: improving Go project CI; fixing .github/workflows/.yml; adding a linter; security scanner as a pipeline job.
Run `npx skills add samber/cc-skills-golang --skill golang-continuous-integration -a claude-code`. Or copy the skill folder (skills/golang-continuous-integration in samber/cc-skills-golang) into .claude/skills/golang-continuous-integration in your project. Claude Code loads it when a task matches its description.
Run `npx skills add samber/cc-skills-golang --skill golang-continuous-integration -a codex`. Or copy the skill folder (skills/golang-continuous-integration in samber/cc-skills-golang) into .agents/skills/golang-continuous-integration in your project. Codex loads it when a task matches its description.
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add samber/cc-skills-golang --skill golang-continuous-integration -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/golang-continuous-integration, .gemini/skills/golang-continuous-integration, .github/skills/golang-continuous-integration and .opencode/skills/golang-continuous-integration in your project.
Going by SKILL.md and its folder, Golang Continuous Integration needs the command-line tools its instructions call (go, git, npx, brew and gh) and credentials named DOCKERHUB_TOKEN and GITHUB_TOKEN. Our summary lists: Docker; A credential in DOCKERHUB_TOKEN; A credential in GITHUB_TOKEN. Its frontmatter pre-approves these tools: Read, Edit, Write, Glob, Grep, Bash(go:*), Bash(golangci-lint:*), Bash(git:*), Agent, WebFetch, Bash(goreleaser:*), Bash(gh:*), AskUserQuestion. Compatibility (from SKILL.md): Designed for Claude Code, Codex or similar harness, and for projects using Golang..
SKILL.md names 1 domain. As links in the text: github.com. This is read from the text; nothing was executed.
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.
Golang Continuous Integration is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.
About 3.7k tokens (SKILL.md is roughly 15k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 984 tokens, read only when the agent opens those files.
Skills that share tags, products or a category with Golang Continuous Integration: Golang Continuous Integration (context-labs/whip, 1.1k stars), Reviewdog (AgentSecOps/SecOpsAgentKit, 220 stars), Sicurezza GitHub (ccplugins/awesome-claude-code-plugins, 970 stars) and Megalinter Check (nvuillam/npm-groovy-lint, 248 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
samber (a GitHub user) maintains it in samber/cc-skills-golang, which has 3,432 GitHub stars. The repository holds 6 skills in this directory. The repository was last updated on October 1, 2026.
Source: samber/cc-skills-golang on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.