Go Error Handling

What it does

When your agent uses it

• Writing Go code that returns
• Handles errors — choosing between sentinel errors
• Fmt.Errorf (%w vs %v)
• Structuring error flow

Example prompts

• “/go-error-handling”

Requirements

• A Bash shell
• Pre-approved tools (allowed-tools): Bash(bash:*)

Workflow steps

4 steps, taken from the first numbered list in SKILL.md.

1. 1System boundary (RPC, IPC, storage)? → Wrap with %v to avoid leaking internals
2. 2Caller needs to match specific conditions? → Sentinel or typed error, wrap with %w
3. 3Caller just needs debugging context? → fmt.Errorf("...: %w", err)
4. 4Leaf function, no wrapping needed? → Return the error directly

What it can do on your machine

Read from SKILL.md and the folder at commit 91f0c2e. 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:

  • Bash(bash:*)

  From allowed-tools in the SKILL.md frontmatter.

• Runs code

  Ships 2 files in scripts/ (Go and Shell), which the agent can run.

  Shell commands in SKILL.md call:

  • bash
  • 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):

  • go.dev
  • pkg.go.dev

  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.

Context cost

Go Error Handling loads about 1.5k tokens when it runs, and up to ~4.7k if it reads all its reference files. Until then it costs about 103 tokens; SKILL.md has 551 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it

~103

When it runs · the whole SKILL.md, loaded when a task matches

~1.5k

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

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); the scripts in this folder are not scanned.

SKILL.md

The full file from cxuu/golang-skills at commit 91f0c2e, republished under its Apache-2.0 licence (© cxuu). 551 words, ~1,501 tokens.

name

go-error-handling

description

Use when writing Go code that returns, wraps, or handles errors — choosing between sentinel errors, custom types, and fmt.Errorf (%w vs %v), structuring error flow, or deciding whether to log or return. Also use when propagating errors across package boundaries or using errors.Is/As, even if the user doesn't ask about error strategy. Does not cover panic/recover patterns (see go-defensive).

allowed-tools

Bash(bash:*)

// Bad: Concrete type can cause subtle bugs
func Bad() *os.PathError { /*...*/ }

// Good: Always return the error interface
func Good() error { /*...*/ }

// Bad
err := fmt.Errorf("Something bad happened.")

// Good
err := fmt.Errorf("something bad happened")

n, _ := b.Write(p) // never returns a non-nil error

g, ctx := errgroup.WithContext(ctx)
g.Go(func() error { return task1(ctx) })
g.Go(func() error { return task2(ctx) })
if err := g.Wait(); err != nil { return err }

// Bad: In-band error value
func Lookup(key string) int  // returns -1 for missing

// Good: Explicit error or ok value
func Lookup(key string) (string, bool)

// Good: Error first, normal code unindented
if err != nil {
    return err
}
// normal code

Error encountered?
├─ Caller can act on it? → Return (with context via %w)
├─ Top of call chain? → Log and handle
└─ Neither? → Log at appropriate level, continue

© cxuu, Apache-2.0. 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 5 other files (scripts, references) in skills/go-error-handling of cxuu/golang-skills.

• SKILL.md
• references/ERROR-FLOW.md
• references/ERROR-TYPES.md
• references/WRAPPING.md
• scripts/check-errors-ast.go
• scripts/check-errors.sh

Open the folder on GitHubat commit 91f0c2e