Golang Database

What it does

When your agent uses it

• Debugging Golang code that interacts with PostgreSQL
• For database testing
• For questions about database/sql

Example prompts

• “/golang-database”

Requirements

• Compatibility (from SKILL.md): Designed for Claude Code, Codex or similar harness, and for projects using Golang.
• Pre-approved tools (allowed-tools): Read, Edit, Write, Glob, Grep, Bash(go:*), Bash(golangci-lint:*), Bash(git:*), Agent, AskUserQuestion

Workflow steps

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

1. 1Use sqlx or pgx, not ORMs — ORMs hide SQL, generate unpredictable queries, and make debugging harder
2. 2Queries MUST use parameterized placeholders — NEVER concatenate user input into SQL strings
3. 3Context MUST be passed to all database operations — use *Context method variants (QueryContext, ExecContext, GetContext)
4. 4sql.ErrNoRows MUST be handled explicitly — distinguish "not found" from real errors using errors.Is
5. 5Rows MUST be closed after iteration — defer rows.Close() immediately after QueryContext calls
6. 6NEVER use db.Query for statements that don't return rows — Query returns *Rows which must be closed; if you forget, the connection leaks…
7. 7Use transactions for multi-statement operations — wrap related writes in BeginTxx/Commit
8. 8Use SELECT ... FOR UPDATE when reading data you intend to modify — prevents race conditions
9. 9Set custom isolation levels when default READ COMMITTED is insufficient (e.g., serializable for financial operations)
10. 10Handle NULLable columns with pointer fields (*string, *int) or sql.NullXxx types
11. 11Connection pool MUST be configured — SetMaxOpenConns, SetMaxIdleConns, SetConnMaxLifetime, SetConnMaxIdleTime
12. 12Use external tools for migrations — golang-migrate or Flyway, never hand-rolled or AI-generated migration SQL

What it can do on your machine

Read from SKILL.md and the folder at commit 772edc7. 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:*)
  • Agent
  • AskUserQuestion

  From allowed-tools in the SKILL.md frontmatter.

• Runs code

  No scripts in the folder and no shell commands in SKILL.md (its code samples are 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
  • flywaydb.org
  • atlasgo.io
  • 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.

• Compatibility

  Designed for Claude Code, Codex or similar harness, and for projects using Golang.

  From compatibility in the SKILL.md frontmatter.

Context cost

Golang Database loads about 2.9k tokens when it runs, and up to ~7.8k if it reads all its reference files. Until then it costs about 122 tokens; SKILL.md has 923 words of instructions outside code blocks.

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

~122

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

~2.9k

With references · SKILL.md plus every file in references/, read only if the agent opens them

~7.8k

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); files beside SKILL.md are not scanned.

SKILL.md

The full file from unxed/f4 at commit 772edc7, republished under its MIT licence (© unxed). 923 words, ~2,869 tokens.

name

golang-database

description

Comprehensive guide for Go database access — parameterized queries, struct scanning, NULLable columns, transactions, isolation levels, SELECT FOR UPDATE, connection pool, batch processing, context propagation, and migration tooling. Use when writing, reviewing, or debugging Golang code that interacts with PostgreSQL, MariaDB, MySQL, or SQLite; for database testing; or for questions about database/sql, sqlx, or pgx. Does NOT generate database schemas or migration SQL.

allowed-tools

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

compatibility

Designed for Claude Code, Codex or similar harness, and for projects using Golang.

user-invocable

true

license

MIT

metadata.author

samber

metadata.version

1.3.2

paths

**/*.go

// ✗ VERY BAD — SQL injection vulnerability
query := fmt.Sprintf("SELECT * FROM users WHERE email = '%s'", email)

// ✓ Good — parameterized (PostgreSQL)
var user User
err := db.GetContext(ctx, &user, "SELECT id, name, email FROM users WHERE email = $1", email)

// ✓ Good — parameterized (MySQL)
err := db.GetContext(ctx, &user, "SELECT id, name, email FROM users WHERE email = ?", email)

query, args, err := sqlx.In("SELECT * FROM users WHERE id IN (?)", ids)
if err != nil {
    return fmt.Errorf("building IN clause: %w", err)
}
query = db.Rebind(query) // adjust placeholders for your driver
err = db.SelectContext(ctx, &users, query, args...)

allowed := map[string]bool{"name": true, "email": true, "created_at": true}
if !allowed[sortCol] {
    return fmt.Errorf("invalid sort column: %s", sortCol)
}
query := fmt.Sprintf("SELECT id, name, email FROM users ORDER BY %s", sortCol)

func GetUser(id string) (*User, error) {
    var user User

    err := db.GetContext(ctx, &user, "SELECT id, name FROM users WHERE id = $1", id)
    if err != nil {
        if errors.Is(err, sql.ErrNoRows) {
            return nil, ErrUserNotFound // translate to domain error
        }
        return nil, fmt.Errorf("querying user %s: %w", id, err)
    }

    return &user, nil
}

func GetUser(id string) (u *User, exists bool, err error) {
    var user User

    err := db.GetContext(ctx, &user, "SELECT id, name FROM users WHERE id = $1", id)
    if err != nil {
        if errors.Is(err, sql.ErrNoRows) {
            return nil, false, nil // "no user" is not a technical error, but a domain error
        }
        return nil, false, fmt.Errorf("querying user %s: %w", id, err)
    }

    return &user, true, nil
}

rows, err := db.QueryContext(ctx, "SELECT id, name FROM users")
if err != nil {
    return fmt.Errorf("querying users: %w", err)
}
defer rows.Close() // prevents connection leaks

for rows.Next() {
    // ...
}
if err := rows.Err(); err != nil { // always check after iteration
    return fmt.Errorf("iterating users: %w", err)
}

// ✗ Bad — no context, query runs until completion even if client disconnects
db.Query("SELECT ...")

// ✓ Good — respects context cancellation and timeouts
db.QueryContext(ctx, "SELECT ...")

db.SetMaxOpenConns(25)              // limit total connections
db.SetMaxIdleConns(10)              // keep warm connections ready
db.SetConnMaxLifetime(5 * time.Minute)  // recycle stale connections
db.SetConnMaxIdleTime(1 * time.Minute)  // close idle connections faster

© unxed, 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 5 other files (references) in .agents/skills/golang-database of unxed/f4.

• SKILL.md
• evals/evals.json
• references/performance.md
• references/scanning.md
• references/testing.md
• references/transactions.md

Open the folder on GitHubat commit 772edc7

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 unxed/f4, which our catalogue first saw on October 7, 2026.

• context-labs/whip.agents/skills/golang-database
• samber/cc-skills-golangskills/golang-database