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 How To

by context-labs in context-labs/whip

Golang skills orchestrator — always active on any Go coding, review, debug, or setup task.

MITAuto-check passedAgent Workflows

Install Golang How To

skills CLI
$ npx skills add context-labs/whip --skill golang-how-to -a claude-code

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

GitHub CLI
$ gh skill install context-labs/whip golang-how-to --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-how-to .claude/skills/golang-how-to && 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-how-to
GitHub stars
1.1k
Used in
1 other repo
Token cost
~3.8k tokens
SKILL.md length
1,478 words
Files
5 (incl. references, assets)
Skills in repo
40
Repo updated
First seen
Licence
MIT

At a glance

Golang skills orchestrator — always active on any Go coding, review, debug, or setup task.

  • Tasks that involve Agent instruction files
  • SKILL.md covers Skill loading, Code navigation with gopls, godig vs gopls vs Context7 vs… and Categories at a glance, plus 2 more sections
  • Calls go

What it does

Golang How To is an agent skill from context-labs/whip. Golang skills orchestrator — always active on any Go coding, review, debug, or setup task. Loads the most relevant samber/cc-skills-golang skills, disambiguating overlapping clusters. Configures agent-config files (CLAUDE.md, AGENTS.md, GEMINI.md, Cursor, Copilot) to force-trigger skills.

Its SKILL.md is about 3.8k tokens, which your agent loads only when the skill is triggered. The skill folder holds 6 other files, including reference files and assets (for example `references/by-category.md`, `references/disambiguation.md` and `references/project-config.md`). Compatibility notes: Designed for Claude Code, Codex or similar harness. Requires git.

It sits in Agent Workflows, covering Agent instruction files. It works with Go. 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

  • Tasks that involve Agent instruction files

Example prompts

  • “/golang-how-to”

Requirements

  • Compatibility (from SKILL.md): Designed for Claude Code, Codex or similar harness. Requires git.
  • Pre-approved tools (allowed-tools): Read, Edit, Write, Glob, Grep, Bash(go:*), Bash(git:*), Agent, AskUserQuestion, LSP, Bash(gopls:*), mcp__gopls__*

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(git:*)
    • Agent
    • AskUserQuestion
    • LSP

    …and 2 more on the same allowed-tools line.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • go

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

  • Network

    Links to these hosts (documentation or services it may open):

    • 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 git.

    From compatibility in the SKILL.md frontmatter.

Context cost

Golang How To loads about 3.8k tokens when it runs, and up to ~15k if it reads all its reference files. Until then it costs about 76 tokens; SKILL.md has 1,478 words of instructions outside code blocks.

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

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,478 words, ~3,806 tokens.

Download SKILL.mdSave it as .claude/skills/golang-how-to/SKILL.md (or your agent's skills folder). This skill also uses 4 other files; get the full folder from GitHub.
name
golang-how-to
description
Golang skills orchestrator — always active on any Go coding, review, debug, or setup task. Loads the most relevant samber/cc-skills-golang skills, disambiguating overlapping clusters. Configures agent-config files (CLAUDE.md, AGENTS.md, GEMINI.md, Cursor, Copilot) to force-trigger skills.
allowed-tools
Read, Edit, Write, Glob, Grep, Bash(go:*), Bash(git:*), Agent, AskUserQuestion, LSP, Bash(gopls:*), mcp__gopls__*
compatibility
Designed for Claude Code, Codex or similar harness. Requires git.
user-invocable
true
license
MIT
metadata.author
samber
metadata.version
1.4.0

Persona: You are a Go skills orchestrator. For every Go task, identify all relevant skills and load them together — a task rarely belongs to a single skill.

Modes:

  • Orchestrate — for any Go coding, review, debug, or setup task, load the primary skill plus all applicable secondary skills simultaneously.
  • Disambiguate — when two skills seem to overlap, show the boundary table. See disambiguation.md.
  • Configure — write the always-load directive for golang-how-to itself, plus an optional ## Required Go skills block, to the project's agent-config file (CLAUDE.md, AGENTS.md, or equivalent). Follow project-config.md.

Questions: In Configure mode, ask the user through the environment's question tool — never as plain-text prose. One question at a time, wait for the answer. If the environment has no question tool, ask in prose with the same options.

Dependencies: gopls — go install golang.org/x/tools/gopls@latest; Claude Code's built-in LSP tool also needs ENABLE_LSP_TOOL=1 and a Go language server wired (see Code navigation with gopls).

Skill loading

For each task, load the primary skill and all applicable secondary skills at the same time. Do not wait — load them together at the start.

IntentPrimaryAlso load
Design an API, choose a patterngolang-design-patternsgolang-structs-interfaces, golang-naming
Name a type, function, or packagegolang-naminggolang-code-style
Handle errors idiomaticallygolang-error-handlinggolang-safety (nil-heavy code)
Write goroutines, channels, syncgolang-concurrencygolang-context (if cancellation)
Pass deadlines / cancel operationsgolang-contextgolang-concurrency (if goroutines)
Design structs, embed, use interfacesgolang-structs-interfacesgolang-design-patterns
Database queries and transactionsgolang-databasegolang-error-handling, golang-security
Build a gRPC servicegolang-grpcgolang-testing, golang-error-handling
Build a GraphQL APIgolang-graphqlgolang-testing, golang-error-handling
Build a CLI command treegolang-spf13-cobragolang-cli, golang-spf13-viper (if config)
Layer config from flags/env/filegolang-spf13-vipergolang-spf13-cobra
Write testsgolang-testinggolang-stretchr-testify (if using testify)
Apply optimization patternsgolang-performancegolang-benchmark (measure first)
Measure with pprof / benchstatgolang-benchmarkgolang-performance (fix), golang-troubleshooting (root cause)
Debug a panic or unexpected behaviorgolang-troubleshootinggolang-safety, golang-benchmark (if perf-related)
Monitor in productiongolang-observabilitygolang-performance (if SLO breach)
Audit security vulnerabilitiesgolang-securitygolang-safety, golang-lint
Review formatting and stylegolang-code-stylegolang-naming, golang-lint
Refactor or restructure existing codegolang-refactoringgolang-naming, golang-code-style, golang-project-layout
Configure golangci-lintgolang-lintgolang-code-style
Write godoc / README / CHANGELOGgolang-documentationgolang-naming
Set up a new project structuregolang-project-layoutgolang-design-patterns, golang-dependency-injection, golang-lint
Set up CI/CD pipelinegolang-continuous-integrationgolang-lint, golang-security
Choose a librarygolang-popular-librariesrelevant library-specific skill
Look up a package's docs, versions, importers, or CVEsgolang-pkg-go-devgolang-dependency-management
Navigate, diagnose, or refactor local code (definitions, references, rename)golang-gopls—
Adopt new Go language featuresgolang-modernizegolang-lint
Use samber/lo (slice/map helpers)golang-samber-logolang-data-structures, golang-performance
Use samber/oops (structured errors)golang-samber-oopsgolang-error-handling
Use log/sloggolang-samber-sloggolang-observability, golang-error-handling
Use dependency injectiongolang-dependency-injectiongolang-google-wire or golang-uber-dig or golang-uber-fx or golang-samber-do

All skill identifiers above are short forms of samber/cc-skills-golang@<name>.

Code navigation with gopls

gopls gives semantic code intelligence for Go — go-to-definition, find references, diagnostics, package API, symbol search, refactoring. → See samber/cc-skills-golang@golang-gopls skill for the three ways to reach it (its own MCP server, the native LSP tool, and its CLI), the full capability matrix, and efficient read/edit workflows.

gopls only reasons about code that is present and resolvable in the local build: your workspace plus every dependency exactly as pinned in go.sum (including replace directives). For any fact that isn't tied to your local build — version history, licenses, ecosystem-wide importers, a package you haven't added yet — use golang-pkg-go-dev (godig). See the godig vs gopls vs Context7 vs govulncheck section below for the full boundary.

godig vs gopls vs Context7 vs govulncheck

Four tools can answer "is this dependency OK to use," and they don't overlap as much as they look:

  • Context7 is a general-purpose, cross-language documentation fetcher — useful when no more specific source exists. For a Go package or module, godig is almost always the better choice: it pulls structured, Go-specific data straight from pkg.go.dev — exact versions, exported symbols with signatures, runnable examples, imported-by, and known vulnerabilities — rather than Context7's generic scraped/curated docs, which don't expose that structure and can lag or miss lesser-known Go modules. Reach for Context7 only when a dependency's documentation genuinely doesn't exist or isn't indexed on pkg.go.dev.
  • godig answers questions about the published ecosystem: any Go package or module, whether or not it's in your go.mod yet — it calls the remote pkg.go.dev API and never touches your local checkout. Its vulns command reports CVEs known for a package/version in isolation, regardless of whether your build actually reaches the vulnerable code path.
  • gopls (→ samber/cc-skills-golang@golang-gopls, via its MCP server, the native LSP tool, or its CLI) answers questions about your specific build: your code plus every dependency exactly as pinned in go.sum, including replace directives pointing at forks or local paths — neither godig nor Context7 can see that. Its go_vulncheck operation runs a single, on-demand reachability check against the workspace as it stands right now.
  • govulncheck (the standalone CLI, wrapped by the samber/cc-skills-golang@golang-security skill) is the whole-tree audit: it walks the entire module's call graph to confirm which known vulnerabilities are actually reachable, and is the tool of record for CI gates and periodic security sweeps — gopls's go_vulncheck is a lighter-weight, single-shot version of the same analysis for use mid-edit.

Pick by task:

TaskToolHow
Find where a symbol is defined in your own repogoplssamber/cc-skills-golang@golang-gopls — go_search, then go_file_context
Understand a file's intra-package dependenciesgoplssamber/cc-skills-golang@golang-gopls — go_file_context
Jump into a dependency's exact resolved source (incl. forks/replaced versions)goplssamber/cc-skills-golang@golang-gopls — go_package_api, or the native LSP tool's goToDefinition
Find every call site in your own code that references a dependency's symbolgoplssamber/cc-skills-golang@golang-gopls — go_symbol_references — godig's imported-by only lists public packages, not call sites in your repo
Get compiler diagnostics right after an editgoplssamber/cc-skills-golang@golang-gopls — go_diagnostics (MCP), or automatic with the native LSP tool
Check whether your current build can reach a known vulnerability, mid-editgoplssamber/cc-skills-golang@golang-gopls — go_vulncheck
Rename, extract, inline, or otherwise refactor local codegoplssamber/cc-skills-golang@golang-gopls — safe rename, refactor.* code actions
Whole-tree vulnerability audit across the module (CI, periodic sweep)govulnchecksamber/cc-skills-golang@golang-security skill — govulncheck ./...
List available versions of a published packagegodiggodig versions <path>
Check known CVEs for a package/version you haven't added yetgodiggodig vulns <path>
See exported symbols/signatures of a published packagegodiggodig symbols / symbol doc
Get runnable code examples for a symbolgodiggodig symbol examples
Read a package's rendered README/docsgodiggodig module readme / package doc
See who imports a package across the whole public ecosystemgodiggodig imported-by
Search for a package or library candidategodiggodig search
Check a package's or module's licensegodiggodig package licenses / module licenses
Get docs for a non-Go library, or a Go module not indexed on pkg.go.devContext7resolve-library-id / query-docs

See the samber/cc-skills-golang@golang-pkg-go-dev skill for the full godig command reference, and the samber/cc-skills-golang@golang-security skill for the whole-tree govulncheck remediation workflow.

Show full SKILL.md (387 more words)Show less

Categories at a glance

Full catalog with "use when" hooks: by-category.md

CategorySkills
Code Qualitygolang-code-style golang-documentation golang-error-handling golang-lint golang-naming golang-safety golang-security golang-structs-interfaces
Architecture & Designgolang-concurrency golang-context golang-data-structures golang-database golang-dependency-injection golang-design-patterns golang-modernize golang-refactoring
QA & Performancegolang-benchmark golang-observability golang-performance golang-testing golang-troubleshooting
Project Setupgolang-cli golang-continuous-integration golang-dependency-management golang-gopls golang-pkg-go-dev golang-popular-libraries golang-project-layout golang-stay-updated
APIsgolang-graphql golang-grpc golang-swagger
Dependency Injectiongolang-dependency-injection golang-google-wire golang-uber-dig golang-uber-fx golang-samber-do
Frameworksgolang-spf13-cobra golang-spf13-viper
samber/*golang-samber-do golang-samber-hot golang-samber-lo golang-samber-mo golang-samber-oops golang-samber-ro golang-samber-slog
Testinggolang-stretchr-testify golang-testing

Competing clusters — boundary lines

Full boundary tables with routing examples: disambiguation.md

Key clusters and their owners:

  • Performance: golang-performance (optimization patterns) · golang-benchmark (measurement) · golang-troubleshooting (root cause) · golang-observability (always-on production)
  • DI: golang-dependency-injection (concepts/decision) · golang-google-wire (compile-time) · golang-uber-dig (runtime reflection) · golang-uber-fx (lifecycle framework) · golang-samber-do (type-safe container)
  • samber/*: golang-samber-lo (finite transforms) · golang-samber-ro (reactive streams) · golang-samber-mo (monadic types)
  • Errors: golang-error-handling (idioms) · golang-samber-oops (structured errors) · golang-safety (prevent panics)
  • Style: golang-code-style · golang-naming · golang-lint · golang-documentation
  • CLI: golang-cli (architecture) · golang-spf13-cobra (command tree) · golang-spf13-viper (config layering)
  • Package lookup: golang-pkg-go-dev (query pkg.go.dev for an existing path: versions/docs/symbols/importers/CVEs) · golang-gopls (navigate/refactor your locally resolved build) · golang-popular-libraries (which library to adopt) · golang-dependency-management (manage go.mod) · golang-security (whole-tree CVE scan)
  • Gap — type vs arch: golang-structs-interfaces (type design) vs golang-design-patterns (architectural patterns)
  • Gap — goroutine vs cancel: golang-concurrency + golang-context — load both when cancelling goroutines via context
  • Gap — correctness vs threat: golang-safety (internal bugs) vs golang-security (external threats)
  • Gap — features vs rules: golang-modernize (language adoption) vs golang-lint (static analysis config)
  • Gap — process vs target rules: golang-refactoring (the safe, staged, at-scale process of changing existing code — planning, ordering, gopls-driven mechanics, staged PRs) vs golang-naming/golang-code-style/golang-project-layout/golang-design-patterns/golang-modernize (what the resulting code should look like) — load golang-refactoring alongside whichever of these owns the target shape

Configure mode

Write an always-load directive for golang-how-to itself to the project's agent-config file (CLAUDE.md, AGENTS.md, GEMINI.md, Cursor rules, or Copilot instructions — whichever the project's harness reads), and optionally force-trigger specific secondary skills too.

samber/cc-skills-golang@golang-project-layout writes the always-load directive automatically at project creation, with no user confirmation needed — it costs one skill description and never imposes project-specific choices. Running /golang-how-to configure writes it too if missing, and additionally lets the user confirm a ## Required Go skills block for skills that must always apply beyond routing. Follow project-config.md.

This skill is not exhaustive. Refer to individual skill files and the official Go documentation for detailed guidance.

If you encounter a bug or unexpected behavior in this skill plugin, open an issue at https://github.com/samber/cc-skills-golang/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 4 other files (references, assets) in .agents/skills/golang-how-to of context-labs/whip.

  • SKILL.md
  • assets/cursor-go-skills.mdc
  • references/by-category.md
  • references/disambiguation.md
  • references/project-config.md

Open the folder on GitHubat commit 8876467

Used in 1 other repository

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

Compare with similar skills

Golang How To 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 How To compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Golang How To this skillcontext-labs/whip1.1k1 repos~3.8kAutomated safety check: PassMIT
Claude Md Dependency Rescanalirezarezvani/ClaudeForge429—~624Automated safety check: PassMIT
Arandu Featurearandu-io/arandu281—~2.5kAutomated safety check: PassMIT
Java Coding StandardsSnailclimb/AIGuide675—~1kAutomated safety check: PassNone
Using Agent Skillsaddyosmani/agent-skills105k4 repos~2.4kAutomated safety check: PassMIT
Claude ReflectBayramAnnakov/claude-reflect1.8k2 repos~627Automated safety check: PassMIT

Similar skills

  • Claude Md Dependency Rescan

    alirezarezvani/ClaudeForge

    Re-detect this project's tech stack from package.json / requirements.txt / pyproject.toml / go.mod / Cargo.toml and diff it against the Tech Stack section of every CLAUDE.md.

    429 GitHub stars~624 tokensUpdated 4 mo ago
    Agent WorkflowsAuto-check passed

  • Arandu Feature

    arandu-io/arandu

    Start here for any change to an Arandu (Go) application that adds or changes behaviour -- "add invoices", "let users publish a post", "send a weekly report", "call the payment provider", "expose…

    281 GitHub stars~2.5k tokensUpdated yesterday
    Agent WorkflowsAuto-check passed

  • Java Coding Standards

    Snailclimb/AIGuide

    Java/Spring Boot 编码规范：用于编写、审查、重构和讲解 Java 代码。适用于 Java 风格、Spring Boot 架构、Controller/Service/Manager/DAO 分层、API 边界、Entity/VO/Form/DTO/BO 设计、MyBatis/MyBatis-Plus 持久化、事务、异常、日志、安全、性能、测试和 Java 代码评审等场景。默认结合…

    675 GitHub stars~1k tokensUpdated 3 mo ago
    Backend & APIsAuto-check passed

  • Using Agent Skills

    addyosmani/agent-skills

    Meta-skill for choosing which workflow skill fits the task at hand, plus always-on habits: surface assumptions, stop on confusion, push back, keep it simple and stay in scope.

    105k GitHub starsUsed in 4 repos~2.4k tokens
    Agent WorkflowsAuto-check passed

  • Claude Reflect

    BayramAnnakov/claude-reflect

    Self-learning system that captures corrections during sessions and reminds users to run /reflect to update CLAUDE.md.

    1.8k GitHub starsUsed in 2 repos~627 tokens
    Agent WorkflowsAuto-check passed

  • Writing For Agents

    bestofjs/bestofjs

    Writing documents for agents. An agent skill from bestofjs/bestofjs.

    3.1k GitHub starsUsed in 20 repos~2.7k tokens
    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 Pkg Go Dev

    context-labs/whip

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

    1.1k GitHub starsUsed in 2 repos~3k 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 6 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

Works with

Categories

Questions about Golang How To

What does Golang How To do?

Golang skills orchestrator — always active on any Go coding, review, debug, or setup task. Golang How To is an agent skill from context-labs/whip. Golang skills orchestrator — always active on any Go coding, review, debug, or setup task.

When should I use Golang How To?

Golang How To fits situations like: tasks that involve Agent instruction files.

How do I install Golang How To in Claude Code?

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

How do I install Golang How To in Codex?

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

Can I use Golang How To 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-how-to -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-how-to, .gemini/skills/golang-how-to, .github/skills/golang-how-to and .opencode/skills/golang-how-to in your project.

What does Golang How To need to run?

Going by SKILL.md and its folder, Golang How To needs the command-line tools its instructions call (go). Its frontmatter pre-approves these tools: Read, Edit, Write, Glob, Grep, Bash(go:*), Bash(git:*), Agent, AskUserQuestion, LSP, Bash(gopls:*), mcp__gopls__*. Compatibility (from SKILL.md): Designed for Claude Code, Codex or similar harness. Requires git..

Does Golang How To access the network?

SKILL.md names 1 domain. As links in the text: github.com. This is read from the text; nothing was executed.

Is Golang How To 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 How To use?

Golang How To 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 How To use?

About 3.8k 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 11k tokens, read only when the agent opens those files.

What are the alternatives to Golang How To?

Skills that share tags, products or a category with Golang How To: Claude Md Dependency Rescan (alirezarezvani/ClaudeForge, 429 stars), Arandu Feature (arandu-io/arandu, 281 stars), Java Coding Standards (Snailclimb/AIGuide, 675 stars) and Using Agent Skills (addyosmani/agent-skills, 105k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Golang How To?

context-labs (a GitHub organization) maintains it in context-labs/whip, which has 1,083 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.