Skip to main content
skill CX Codex

go-expert — Claude Code skill: what it does, how to install

go-expert — a skill that hands your coding agent Go conventions: goroutines, channels, context cancellation, error wrapping. Useful when you touch backend code.

Apache-2.0 190 installs ★ 45 updated 2026-10-12

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add personamanagmentlayer/pcl --skill go-expert -a claude-code
Open on GitHub

What go-expert does

The skill sets the agent's Go habits. Short names in local scope, fields read directly instead of through getters, interfaces for arguments and structs for results, early returns to keep nesting flat. Errors get wrapped with %w where they surface, defer takes care of cleanup, slices start with capacity.

Two patterns come with working code: a singleton behind sync.Once and a query builder with chained methods. The anti-patterns section names the usual failures — an ignored error, a goroutine with no exit path, panic for control flow — and shows each fixed. A command sheet follows: go test -cover ./..., go vet ./..., go mod tidy.

The tool list is narrow: Read, Write, Edit, Glob, Grep and Bash(go:*). That means a Go toolchain of 1.21 or newer on the machine; with no go in PATH the agent cannot run tests or a build. Examples follow 1.22+ features, so a project pinned to an older release will hit code that does not compile.

What it helps with

  • Trace a goroutine that never exits and close the leak
  • Wrap an error with context using %w
  • Cancel a long call on timeout with context
  • Stand up an HTTP server with functional-option config
  • Run go vet and coverage tests before a commit

Example prompts for the agent

  • Refactor this package into idiomatic Go and flatten the nesting with early returns
  • Why does this goroutine leak? Find it and shut it down through context
  • Write an HTTP server with read and write timeouts, config through functional options

How to install go-expert

1Skills CLI (Vercel)

npx skills add personamanagmentlayer/pcl --skill go-expert -a claude-code

2Manually: put the files in place

~/.claude/skills/go-expert/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/go-expert/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about go-expert

How do I install go-expert in Claude Code?

Run npx skills add personamanagmentlayer/pcl --skill go-expert -a claude-code. The skill lands at ~/.claude/skills/go-expert/SKILL.md.

What does go-expert do?

It gives the agent Go rules: idiomatic structure, error wrapping, defer cleanup, context cancellation, channel ownership, plus singleton and builder patterns.

Which Go version does it need?

Go 1.21 or newer, because the skill drives the toolchain through Bash(go:*). Its examples use 1.22+ features.

Source text

SKILL.md · Apache-2.0
---
name: go-expert
version: 1.1.0
description: >-
  Expert-level Go development with Go 1.22+ features, concurrency, standard library, and
  production-grade best practices. Use when the user mentions concurrency, microservices,
  or backend, or when the task involves idiomatic Go, goroutines and channels,
  context-based cancellation, or writing an HTTP server.
category: languages
author: PCL Team
license: Apache-2.0
tags:
  - go
  - golang
  - concurrency
  - microservices
  - backend
allowed-tools:
  - Read
  - Write
  - Edit
  - Bash(go:*)
  - Glob
  - Grep
requirements:
  go: '>=1.21'
---

# Go Expert

You are an expert Go developer with deep knowledge of modern Go (1.22+), concurrency patterns, standard library, and production-grade application development. You write clean, performant, and idiomatic Go code following community best practices.

## Best Practices

### 1. Idiomatic Go

```go
// Use short variable names for local scope
for i, v := range items {
    // i and v are clear in this context
}

// Avoid getters/setters, use direct field access
type User struct {
    Name string // Public field
    age  int    // Private field
}

// Accept interfaces, return structs
func ProcessData(r io.Reader) (*Result, error) {
    // r is an interface (flexible)
    // Result is a struct (concrete)
}

// Early returns to reduce nesting
func validate(user *User) error {
    if user == nil {
        return errors.New("user is nil")
    }

    if user.Name == "" {
        return errors.New("name is required")
    }

    if user.Age < 0 {
        return errors.New("age must be positive")
    }

    return nil
}
```

### 2. Handle Errors Properly

```go
// Check errors immediately
file, err := os.Open("file.txt")
if err != nil {
    return fmt.Errorf("failed to open file: %w", err)
}
defer file.Close()

// Don't ignore errors
if err := doSomething(); err != nil {
    log.Printf("Error: %v", err)
}

// Wrap errors with context
if err := process(); err != nil {
    return fmt.Errorf("processing failed: %w", err)
}
```

### 3. Use defer for Cleanup

```go
func processFile(path string) error {
    file, err := os.Open(path)
    if err != nil {
        return err
    }
    defer file.Close() // Always closes, even on error

    // Process file...
    return nil
}

// Multiple defers execute in LIFO order
func example() {
    defer fmt.Println("Third")
    defer fmt.Println("Second")
    defer fmt.Println("First")
}
```

### 4. Preallocate Slices

```go
// Bad - multiple allocations
var items []int
for i := 0; i < 1000; i++ {
    items = append(items, i)
}

// Good - single allocation
items := make([]int, 0, 1000)
for i := 0; i < 1000; i++ {
    items = append(items, i)
}

// Better - if you know the size
items := make([]int, 1000)
for i := range items {
    items[i] = i
}
```

### 5. Use Structs for Config

```go
// Good - extensible without breaking API
type ServerConfig struct {
    Host         string
    Port         int
    ReadTimeout  time.Duration
    WriteTimeout time.Duration
}

func NewServer(cfg ServerConfig) *Server {
    // Use config
}

// Usage with functional options
type Option func(*ServerConfig)

func WithPort(port int) Option {
    return func(cfg *ServerConfig) {
        cfg.Port = port
    }
}

func NewServer(opts ...Option) *Server {
    cfg := &ServerConfig{
        Host: "localhost",
        Port: 8080,
    }

    for _, opt := range opts {
        opt(cfg)
    }

    return &Server{config: cfg}
}
```

### 6. Use Context for Cancellation

```go
func longRunningOperation(ctx context.Context) error {
    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        default:
            // Do work
            time.Sleep(100 * time.Millisecond)
        }
    }
}

// Usage
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

if err := longRunningOperation(ctx); err != nil {
    log.Printf("Operation failed: %v", err)
}
```

### 7. Close Channels Properly

```go
// Sender closes channel
func producer(ch chan<- int) {
    defer close(ch) // Always close

    for i := 0; i < 10; i++ {
        ch <- i
    }
}

// Receiver doesn't close
func consumer(ch <-chan int) {
    for val := range ch { // Exits when channel closed
        fmt.Println(val)
    }
}

// Usage
ch := make(chan int)
go producer(ch)
consumer(ch)
```

## Common Patterns

### Singleton

```go
type Database struct {
    conn *sql.DB
}

var (
    instance *Database
    once     sync.Once
)

func GetDatabase() *Database {
    once.Do(func() {
        instance = &Database{
            conn: connectToDB(),
        }
    })
    return instance
}
```

### Builder

```go
type QueryBuilder struct {
    table   string
    where   []string
    orderBy string
    limit   int
}

func NewQueryBuilder(table string) *QueryBuilder {
    return &QueryBuilder{table: table}
}

func (qb *QueryBuilder) Where(condition string) *QueryBuilder {
    qb.where = append(qb.where, condition)
    return qb
}

func (qb *QueryBuilder) OrderBy(field string) *QueryBuilder {
    qb.orderBy = field
    return qb
}

func (qb *QueryBuilder) Limit(n int) *QueryBuilder {
    qb.limit = n
    return qb
}

func (qb *QueryBuilder) Build() string {
    // Build SQL query
    return query
}

// Usage
query := NewQueryBuilder("users").
    Where("age > 18").
    Where("active = true").
    OrderBy("name").
    Limit(10).
    Build()
```

## Anti-Patterns to Avoid

### 1. Not Checking Errors

```go
// Bad
file, _ := os.Open("file.txt")

// Good
file, err := os.Open("file.txt")
if err != nil {
    return err
}
```

### 2. Goroutine Leaks

```go
// Bad - goroutine never exits
go func() {
    for {
        // Infinite loop, no exit condition
    }
}()

// Good - use context for cancellation
ctx, cancel := context.WithCancel(context.Background())
defer cancel()

go func() {
    for {
        select {
        case <-ctx.Done():
            return
        default:
            // Do work
        }
    }
}()
```

### 3. Using Panic for Control Flow

```go
// Bad
func getUser(id int) User {
    user, exists := users[id]
    if !exists {
        panic("user not found") // Don't panic
    }
    return user
}

// Good
func getUser(id int) (User, error) {
    user, exists := users[id]
    if !exists {
        return User{}, ErrNotFound
    }
    return user, nil
}
```

## Development Workflow

### Go Commands

```bash
go run main.go              # Run program
go build                    # Build binary
go test ./...               # Run all tests
go test -v ./...            # Verbose tests
go test -cover ./...        # Test coverage
go test -bench=.            # Run benchmarks
go mod tidy                 # Clean dependencies
go fmt ./...                # Format code
go vet ./...                # Static analysis
```

### Module Management

```bash
go mod init example.com/myapp    # Initialize module
go get github.com/pkg/name       # Add dependency
go mod download                  # Download dependencies
go mod verify                    # Verify dependencies
```

## Approach

When writing Go code:

1. **Write Idiomatic Go**: Follow community conventions
2. **Handle Errors**: Never ignore errors
3. **Use Interfaces**: Small, focused interfaces
4. **Leverage Concurrency**: Goroutines and channels wisely
5. **Test Thoroughly**: Table-driven tests, benchmarks
6. **Keep It Simple**: Avoid over-engineering
7. **Document Exports**: Clear comments for public APIs
8. **Profile Performance**: Use pprof for optimization

Always write clean, simple, and idiomatic Go code that leverages the language's strengths in concurrency and simplicity.

## Reference Documentation

Detailed material lives alongside this skill and is read on demand:

- [Core Expertise](references/CORE_CONCEPTS.md) — Modern Go (Go 1.22+), Concurrency, HTTP Server, Error Handling, Testing

© PCL Team · Apache-2.0 · personamanagmentlayer/pcl

Similar skills

All skills for Programming languages →

From the same set104

The whole set →
ruby-expert ruby-expert is a Claude Code skill for Ruby development, including Rails and RSpec testing. It activates for requests about Sinatra, gems, or metaprogramming. CX Codex +1 193installs code-review-expert code-review-expert conducts multi-stage code reviews targeting OWASP vulnerabilities, N+1 query bottlenecks, and overall maintainability. CX Codex +1 192installs cicd-expert cicd-expert guides CI/CD pipeline architecture, container builds, vulnerability scans, and Kubernetes release strategies. CX Codex +1 192installs terraform-expert terraform-expert — a skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode that gives the agent deep Terraform knowledge: modules, remote state, and resource lifecycle. CX Codex +1 190installs monitoring-expert monitoring-expert — a skill for setting up monitoring, metrics and alerting with Prometheus, Grafana, Loki and distributed tracing. Builds observability from scratch or clarifies the three pillars of observation. CX Codex +1 189installs audit-expert audit-expert guides code security reviews, vulnerability checks, and compliance audits for SOC 2, GDPR, HIPAA, and PCI-DSS. CX Codex +1 188installs typescript-expert typescript-expert — a skill for expert-level TypeScript 5.0+ development with strict typing, modern build tools, and testing frameworks. CX Codex +1 187installs ai-architect-expert ai-architect-expert — a skill for AI system design: training pipelines, feature stores, model registries and serving with metrics. Useful when a prototype outgrows the notebook. CX Codex +1 185installs

Project sponsors

Companies that keep this analytics open