New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Golang Pkg Go Dev

by context-labs in context-labs/whip

Golang package/module docs via godig, a pkg.go.dev API client (CLI + MCP) — APIs, symbols, versions, importers, licenses, vulnerabilities.

MITAuto-check passedSecurity

Install Golang Pkg Go Dev

skills CLI
$ npx skills add context-labs/whip --skill golang-pkg-go-dev -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install context-labs/whip golang-pkg-go-dev --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/context-labs/whip.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/golang-pkg-go-dev .claude/skills/golang-pkg-go-dev && rm -rf skills-src

Use ~/.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/

Facts

Skill name
golang-pkg-go-dev
GitHub stars
1.1k
Used in
2 other repos
Token cost
~3k tokens
SKILL.md length
1,092 words
Files
2 (incl. references)
Skills in repo
40
Repo updated
First seen
Licence
MIT

At a glance

Golang package/module docs via godig, a pkg.go.dev API client (CLI + MCP) — APIs, symbols, versions, importers, licenses, vulnerabilities.

  • Look up Go library docs
  • SKILL.md covers When to use this skill, Choosing between godig, gopls,…, Setup and Commands
  • Calls claude and go; reaches godig.samber.dev
  • CVEs — prefer over Context7

What it does

Golang Pkg Go Dev is an agent skill from context-labs/whip. Golang package/module docs via godig, a pkg.go.dev API client (CLI + MCP) — APIs, symbols, versions, importers, licenses, vulnerabilities. Use to look up Go library docs, signatures, or CVEs — prefer over Context7. Not for deps, library choice, local symbols (→ golang-gopls).

Its SKILL.md is about 3k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files, including reference files (for example `references/sample-output.md`). Compatibility notes: Designed for Claude Code, Codex or similar harness. Requires the godig CLI (go install github.com/samber/godig/cmd/godig@latest) or access to a godig MCP…

It sits in Security, covering Vulnerability scanning and MCP servers. It works with Go and Model Context Protocol. The repository describes itself as: A fast coding-agent harness in Go. Tool-use loop, bubbletea TUI, provider-routable models with live catalog discovery, MCP support, background subagents. One binary, no runtime… The licence is MIT.

When your agent uses it

  • Look up Go library docs
  • CVEs — prefer over Context7

Example prompts

  • “/golang-pkg-go-dev”

Requirements

  • Compatibility (from SKILL.md): Designed for Claude Code, Codex or similar harness. Requires the godig CLI (go install github.com/samber/godig/cmd/godig@latest) or access to a godig MCP server, and internet access to reach the pkg.go.dev API.
  • Pre-approved tools (allowed-tools): Read, Edit, Write, Glob, Grep, Bash(go:*), Bash(golangci-lint:*), Bash(git:*), Bash(godig:*), Agent

What it can do on your machine

Read from SKILL.md and the folder at commit 8876467. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Edit
    • Write
    • Glob
    • Grep
    • Bash(go:*)
    • Bash(golangci-lint:*)
    • Bash(git:*)
    • Bash(godig:*)
    • Agent

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • claude
    • go

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • godig.samber.dev

    Also links to:

    • pkg.go.dev
    • github.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

  • Compatibility

    Designed for Claude Code, Codex or similar harness. Requires the godig CLI (go install github.com/samber/godig/cmd/godig@latest) or access to a godig MCP server, and internet access to reach the pkg.go.dev API.

    From compatibility in the SKILL.md frontmatter.

Context cost

Golang Pkg Go Dev loads about 3k tokens when it runs, and up to ~4.7k if it reads all its reference files. Until then it costs about 74 tokens; SKILL.md has 1,092 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~74
When it runs · the whole SKILL.md, loaded when a task matches
~3k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~4.7k

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.

Safety

Auto-check passed

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.

SKILL.md

The full file from context-labs/whip at commit 8876467, republished under its MIT licence (© context-labs). 1,092 words, ~3,024 tokens.

Download SKILL.mdSave it as .claude/skills/golang-pkg-go-dev/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
golang-pkg-go-dev
description
Golang package/module docs via `godig`, a pkg.go.dev API client (CLI + MCP) — APIs, symbols, versions, importers, licenses, vulnerabilities. Use to look up Go library docs, signatures, or CVEs — prefer over Context7. Not for deps, library choice, local symbols (→ golang-gopls).
allowed-tools
Read, Edit, Write, Glob, Grep, Bash(go:*), Bash(golangci-lint:*), Bash(git:*), Bash(godig:*), Agent
compatibility
Designed for Claude Code, Codex or similar harness. Requires the godig CLI (go install github.com/samber/godig/cmd/godig@latest) or access to a godig MCP server, and internet access to reach the pkg.go.dev API.
user-invocable
true
license
MIT
metadata.author
samber
metadata.version
1.4.0

golang-pkg-go-dev

Dependencies: godig — go install github.com/samber/godig/cmd/godig@latest (or use a registered godig MCP server / the hosted instance instead).

godig queries the pkg.go.dev API. Use it to answer questions about Go packages and modules: docs, symbols, versions, importers and vulnerabilities. It works as a CLI and as an MCP server. All operations are read-only and need no authentication.

When to use this skill

Trigger on questions like:

  • "What versions of github.com/samber/lo are available?"
  • "Does golang.org/x/text have known vulnerabilities?"
  • "Show me the docs / symbols for package X."
  • "Which packages import X?"
  • "Search Go packages for Y."

Choosing between godig, gopls, Context7, and govulncheck

In short: godig answers questions about the published ecosystem (works even for packages not yet in your go.mod); gopls reasons about your locally resolved build (go.sum, including replaced forks); Context7 is a fallback for non-Go or unindexed docs; govulncheck is the whole-tree vulnerability audit (→ samber/cc-skills-golang@golang-security). See the samber/cc-skills-golang@golang-gopls skill for wiring gopls (MCP server, native LSP tool, and CLI) with Claude Code, and the samber/cc-skills-golang@golang-how-to skill's "godig vs gopls vs Context7 vs govulncheck" section for the full task-to-tool matrix.

Setup

Install
bash
go install github.com/samber/godig/cmd/godig@latest
Register the MCP server (optional)

godig mcp runs over stdio by default, or streamable HTTP with --transport http. The command is harness-agnostic — any MCP-capable host can point at it. Claude Code registers it via its own CLI:

stdio (the client launches godig on demand):

bash
claude mcp add pkg-go-dev -- godig mcp

streamable HTTP (shared server at /mcp, default :8080):

bash
godig mcp --transport http --addr :8080
claude mcp add --transport http pkg-go-dev http://localhost:8080/mcp

Hosted instance (no install needed) — a public server runs at https://godig.samber.dev/mcp:

bash
claude mcp add --transport http pkg-go-dev https://godig.samber.dev/mcp

Other MCP-capable harnesses (Cursor, Windsurf, and others) each have their own MCP server registration — an entry in their respective settings file pointing at the same godig mcp command or hosted URL, not a shared config format.

The CLI and the MCP server expose the same operations under matching names. Prefer the CLI when godig is installed; the hosted instance is a fallback when it is not.

Commands

Global flags (all commands): -o/--output table|json|raw|md (default table — pass -o md for chat), --base-url (pkg.go.dev API), --vuln-base-url (Go vulnerability database, consulted by vulns and overview), --timeout, --log-level debug|info|warn|error|off. All are also settable via GODIG_* env vars.

CommandArgsSpecific flagsPurpose
overview<path>--versionCompact summary (metadata, versions, licenses, vulns) — start here
search<query>--symbol --limit --filterFind packages (optionally exporting a symbol)
package info<path>--module --versionPackage metadata
package imports<path>--module --versionPackages this package imports (plain list)
package doc<path>--module --version --goos --goarch --format md|text|html|markdownFull package doc (LARGE)
package examples<path>--module --version --goos --goarch --symbolRunnable examples (LARGE; scope with --symbol)
package licenses<path>--module --versionLicense files, full text (LARGE)
symbol doc<path> <symbol>--module --version --goos --goarchOne symbol's signature + doc (token-efficient)
symbol examples<path> <symbol>--module --version --goos --goarchOne symbol's runnable examples
symbols<path>--module --version --goos --goarch --limit --filterList exported symbols
module info<path>--versionModule metadata
module licenses<path>--versionModule license files (LARGE)
module readme<path>--versionModule README, full Markdown (LARGE)
dependencies<path>--versiongo.mod deps: requires / replaces / excludes / go directive
packages<path>--version --limit --filterPackages contained in a module
versions<path>--limit --filterAll versions, newest first
major-versions<path>--limit --filter --exclude-pseudoMajor versions (v1, v2 …) living as separate modules
imported-by<path>--module --version --limit --filterPackages that import this one
vulns<path>--version --limitKnown vulnerabilities (from the Go vuln DB)
mcp—--transport stdio|http --addr --cache-ttl --cache-sizeRun as an MCP server
version——Print godig version / commit / build date

When godig runs as an MCP server, each data command above is exposed as an operation of the same name.

Exit codes: 0 success, 1 runtime error (network, package not found), 2 usage error — a missing/invalid argument or flag (e.g. a non-positive --limit), or a command group invoked with no subcommand (godig package). Check for 2 to tell a malformed call apart from a failed lookup.

Full -o md output for every command: sample-output.md.

Show full SKILL.md (449 more words)Show less
Tips
  • Start with overview — one call returns a compact summary (metadata, latest + recent versions, license types, vulnerabilities). Reach for doc/examples/module readme/licenses (LARGE) only when the full text is needed.
  • Always pass -o md so results render as Markdown (tables, or raw doc/README) in the chat. Other formats exist (table default, json, raw) but prefer md here.
  • <path> is a full import path, e.g. github.com/samber/lo — pass it as the positional argument.
  • --version pins a specific module version (v1.5.0, latest, master, main); --module disambiguates which module a package belongs to.
  • --filter narrows list results server-side with a Go boolean expression — see Filter syntax.
  • --goos/--goarch set the documentation/symbols build context (e.g. linux/amd64).
  • Prefer symbol doc/symbol examples over the package-wide package doc/package examples when you only need one symbol — far fewer tokens.
  • Parallelize independent lookups — every command is a self-contained, read-only HTTP query, so calls never depend on each other. When a task needs docs, examples, versions, or vulns for several symbols, packages, or modules, issue all the calls at once (multiple godig invocations in a single turn) rather than one after another — wall-clock drops from sum-of-latencies to slowest-single-call. For a large fan-out (documenting many symbols, comparing many candidate libraries, auditing CVEs across a dependency set), dispatch up to 5 parallel sub-agents, each running its own godig calls and returning a compact summary, so the raw LARGE output never lands in the main context.
  • Listing commands auto-paginate (return all results); use --limit to cap.
Filter syntax

--filter (on search, versions, major-versions, packages, imported-by, symbols) takes a Go boolean expression evaluated server-side, once per result item. It is not a regex — wrap the whole expression in single quotes for the shell.

  • Identifiers are the item's fields, which differ per command — a field valid for one list is rejected by another (e.g. search exposes packagePath, not path). An unknown field fails with undefined identifier: <name> (HTTP 400), which names the offending field. Fields use the item's lowercase JSON key; the exception is enum-like values such as kind, which are capitalized (Function, not func).
  • Operators: == != < <= > >=, boolean && || !, parentheses for grouping.
  • String functions: contains(s, sub), hasPrefix(s, pre), hasSuffix(s, suf).
  • Literals: double-quoted strings ("Function"), true/false, numbers.

Filterable fields per command (string unless noted):

CommandFields
searchmodulePath, packagePath, synopsis, version
versionsversion, modulePath, deprecated (bool), retracted (bool), hasGoMod (bool), commitTime
packagespath, name, synopsis, isRedistributable (bool)
imported-bypath (the importing package path)
symbolsname, kind (Function/Method/Type/Variable/Constant), synopsis, parent
major-versionsmodulePath, major, version, isLatest (bool)
bash
godig symbols github.com/samber/lo --filter 'kind=="Function"' -o md
godig symbols github.com/samber/lo --filter 'kind=="Function" && hasPrefix(name,"Map")' -o md
godig versions github.com/samber/lo --filter 'hasPrefix(version,"v1.5")' -o md
godig versions github.com/samber/lo --filter 'deprecated==false && retracted==false' -o md
godig search "result option" --filter 'hasPrefix(packagePath,"github.com/samber/")' -o md
Examples

Always request Markdown output (-o md):

bash
# Overview — start here (compact, one call)
godig overview github.com/samber/ro -o md

# Search
godig search "result option monad" --limit 5 -o md

# Package facets
godig package info github.com/samber/ro -o md
godig package imports github.com/samber/ro -o md
godig package doc github.com/samber/ro --format md -o md
godig package examples github.com/samber/ro --symbol Map -o md
godig package licenses github.com/samber/ro -o md

# Single symbol (token-efficient vs package-wide doc/examples)
godig symbol doc github.com/samber/lo Map -o md
godig symbol examples github.com/samber/oops OopsError.Error -o md

# Module facets
godig module info github.com/samber/ro -o md
godig module readme github.com/samber/ro -o raw
godig dependencies github.com/samber/ro -o md

# Lists (auto-paginated; --limit to cap)
godig versions github.com/samber/ro -o md
godig major-versions github.com/samber/lo -o md
godig packages github.com/samber/ro -o md
godig imported-by github.com/samber/ro --limit 20 -o md
godig symbols github.com/samber/ro --filter 'kind=="Function"' -o md

# Pin a version / set the build context
godig versions github.com/samber/ro --filter 'hasPrefix(version,"v0.3")' -o md
godig package doc github.com/samber/lo --version v1.50.0 -o md
godig symbols github.com/samber/ro --goos linux --goarch amd64 -o md

# Vulnerabilities
godig vulns github.com/samber/ro -o md

This skill is not exhaustive. godig --help and each sub-command's --help list current flags and output formats; the data mirrors what pkg.go.dev exposes.

If you encounter a bug or unexpected behavior in godig, open an issue at https://github.com/samber/godig/issues.

© context-labs, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1 other file (references) in .agents/skills/golang-pkg-go-dev of context-labs/whip.

  • SKILL.md
  • references/sample-output.md

Open the folder on GitHubat commit 8876467

Used in 2 other repositories

We found 2 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 2 other GitHub owners. This page covers the copy in context-labs/whip, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Golang Pkg Go Dev 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.

Golang Pkg Go Dev compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Golang Pkg Go Dev this skillcontext-labs/whip1.1k2 repos~3kAutomated safety check: PassMIT
Forensifyalexgreensh/repo-forensics188—~2.5kAutomated safety check: NotesCustom licence
Docsboostsecurityio/poutine523—~336Automated safety check: PassApache-2.0
Security Vuln Remediationstacklok/toolhive-studio170—~2.3kAutomated safety check: NotesApache-2.0
Local DevSmilyOrg/photofield608—~2.4kAutomated safety check: PassMIT
Gas Executiontanaikech/ggsrun173—~2.5kAutomated safety check: PassMIT

Similar skills

  • Forensify

    alexgreensh/repo-forensics

    Cross-agent self-inspection of your AI-agent stack. An agent skill from alexgreensh/repo-forensics.

    188 GitHub stars~2.5k tokensUpdated 11 days ago
    SecurityAuto-check: notes

  • Docs

    boostsecurityio/poutine

    Update project documentation when features are added or changed.

    523 GitHub stars~336 tokensUpdated 2 days ago
    SecurityAuto-check passed

  • Security Vuln Remediation

    stacklok/toolhive-studio

    Remediate security vulnerabilities found by Grype or pnpm audit.

    170 GitHub stars~2.3k tokensUpdated yesterday
    SecurityAuto-check: notes

  • Local Dev

    SmilyOrg/photofield

    Run, test, and debug the photofield server locally. An agent skill from SmilyOrg/photofield.

    608 GitHub stars~2.4k tokensUpdated 1 mo ago
    Agent WorkflowsAuto-check passed

  • Gas Execution

    tanaikech/ggsrun

    Guidelines for writing and executing Google Apps Script code using ggsrun and finding documentation via workspace-developer.

    173 GitHub stars~2.5k tokensUpdated 1 mo ago
    Agent WorkflowsAuto-check passed

  • fp-go MCP Server Setup

    IBM/fp-go

    Official

    Configures and queries the fp-go MCP server so Claude Code, Claude Desktop or another MCP client can search fp-go's examples and skills directly.

    2k GitHub stars~3.3k tokensUpdated yesterday
    Agent WorkflowsAuto-check passed

More from context-labs/whip

All 40 skills in this repo

  • Golang Lint

    context-labs/whip

    Linting best practices and golangci-lint configuration for Go — running linters, configuring .golangci.yml, nolint suppressions, selecting linters.

    1.1k GitHub starsUsed in 2 repos~1.8k tokens
    Auto-check passed

  • Golang Project Layout

    context-labs/whip

    Golang project layouts and workspaces. An agent skill from context-labs/whip.

    1.1k GitHub starsUsed in 1 repo~1.8k tokens
    Auto-check passed

  • Golang Stretchr Testify

    context-labs/whip

    Golang testing with stretchr/testify — assert, require, mock, suite: assertions, mock expectations, argument matchers, suite lifecycle, Eventually, JSONEq.

    1.1k GitHub starsUsed in 2 repos~1.8k tokens
    Auto-check passed

  • Golang Continuous Integration

    context-labs/whip

    CI/CD with GitHub Actions for Golang — testing, linting, SAST, security scanning, coverage, Dependabot, Renovate, GoReleaser, release pipelines.

    1.1k GitHub stars~3.5k tokensUpdated 3 days ago
    Auto-check passed

  • Golang Data Structures

    context-labs/whip

    Golang data structures — slices/maps internals (capacity growth, preallocation, hash buckets), slices/maps packages, container/list/heap/ring, strings.Builder vs bytes.Buffer, generic collections…

    1.1k GitHub starsUsed in 1 repo~2.6k tokens
    Auto-check passed

  • Golang Grpc

    context-labs/whip

    gRPC usage, protobuf organization, and production patterns for Go microservices.

    1.1k GitHub starsUsed in 1 repo~2.5k tokens
    Auto-check passed

Works with

Categories

Questions about Golang Pkg Go Dev

What does Golang Pkg Go Dev do?

Golang package/module docs via godig, a pkg.go.dev API client (CLI + MCP) — APIs, symbols, versions, importers, licenses, vulnerabilities. Golang Pkg Go Dev is an agent skill from context-labs/whip.dev API client (CLI + MCP) — APIs, symbols, versions, importers, licenses, vulnerabilities.

When should I use Golang Pkg Go Dev?

Golang Pkg Go Dev fits situations like: look up Go library docs; CVEs — prefer over Context7.

How do I install Golang Pkg Go Dev in Claude Code?

Run `npx skills add context-labs/whip --skill golang-pkg-go-dev -a claude-code`. Or copy the skill folder (.agents/skills/golang-pkg-go-dev in context-labs/whip) into .claude/skills/golang-pkg-go-dev in your project. Claude Code loads it when a task matches its description.

How do I install Golang Pkg Go Dev in Codex?

Run `npx skills add context-labs/whip --skill golang-pkg-go-dev -a codex`. Or copy the skill folder (.agents/skills/golang-pkg-go-dev in context-labs/whip) into .agents/skills/golang-pkg-go-dev in your project. Codex loads it when a task matches its description.

Can I use Golang Pkg Go Dev in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add context-labs/whip --skill golang-pkg-go-dev -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-pkg-go-dev, .gemini/skills/golang-pkg-go-dev, .github/skills/golang-pkg-go-dev and .opencode/skills/golang-pkg-go-dev in your project.

What does Golang Pkg Go Dev need to run?

Going by SKILL.md and its folder, Golang Pkg Go Dev needs the command-line tools its instructions call (claude and go). Its frontmatter pre-approves these tools: Read, Edit, Write, Glob, Grep, Bash(go:*), Bash(golangci-lint:*), Bash(git:*), Bash(godig:*), Agent. Compatibility (from SKILL.md): Designed for Claude Code, Codex or similar harness. Requires the godig CLI (go install github.com/samber/godig/cmd/godig@latest) or access to a godig MCP server, and internet access to reach the pkg.go.dev API..

Does Golang Pkg Go Dev access the network?

SKILL.md names 3 domains. In commands or code: godig.samber.dev; the agent is likely to contact it when it follows the instructions. As links in the text: pkg.go.dev and github.com. This is read from the text; nothing was executed.

Is Golang Pkg Go Dev safe to install?

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.

What licence does Golang Pkg Go Dev use?

Golang Pkg Go Dev is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Golang Pkg Go Dev use?

About 3k tokens (SKILL.md is roughly 12k 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 1.7k tokens, read only when the agent opens those files.

What are the alternatives to Golang Pkg Go Dev?

Skills that share tags, products or a category with Golang Pkg Go Dev: Forensify (alexgreensh/repo-forensics, 188 stars), Docs (boostsecurityio/poutine, 523 stars), Security Vuln Remediation (stacklok/toolhive-studio, 170 stars) and Local Dev (SmilyOrg/photofield, 608 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Golang Pkg Go Dev?

context-labs (a GitHub organization) maintains it in context-labs/whip, which has 1,081 GitHub stars. The repository holds 40 skills in this directory. The repository was last updated on October 5, 2026.

Source: context-labs/whip on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.