go-development

Files (1)

• SKILL.md

SKILL.md (first lines)

# Go Development

Production patterns and idioms for Go programming, covering project structure, error handling,
concurrency, interfaces, testing, and module management.

## When to Use This Skill

- Starting or structuring a Go project
- Writing idiomatic Go error handling
- Working with goroutines and channels
- Designing interfaces and composable packages
- Writing tests with `go test`
- Managing dependencies with Go modules
- Using context for cancellation and propagation

## Core Concepts

### 1. Project Layout

```
myapp/
├── cmd/
│   └── myapp/
│       └── main.go          # Entry point
├── internal/                 # Private packages (not importable externally)
│   ├── handler/
│   │   └── handler.go
│   ├── service/
│   │   └── service.go
│   └── repository/
│       └── repository.go
├── pkg/                      # Public reusable packages
│   └── httputil/
│       └── response.go
├── go.mod
├── go.sum
├── Makefile
└── README.md
```

### 2. Key Principles

| Principle      | Go Idiom                                        |
|----------------|-------------------------------------------------|
| Error handling | Return `error` as last value, check immediately |
| Composition    | Embed interfaces, not structs                   |
| Concurrency    | Share memory by communicating (channels)        |
| Simplicity     | Fewer abstractions, explicit over implicit      |
| Zero values    | Design types so zero value is useful            |

## Quick Start

```bash
# Initialize a new module
go mod init github.com/user/myapp

# Add dependencies
go get github.com/gin-gonic/gin@latest

# Tidy dependencies
go mod tidy

# Build and run
go build -o myapp ./cmd/myapp
go run ./cmd/myapp

# Run tests
go test ./...
go test -v -race -count=1 ./...
```

## Patterns

### Pattern 1: Error Handling

```go
package service

import (
    "errors"
    "fmt"
)

// Define sentinel errors for comparison
var (
    ErrNotFound     = errors.New("not found")
    ErrUnauthorized = errors.New("unauthorized")
)

// Custom error type with context
type ValidationError struct {
    Field   string
    Message string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("validation failed on %s: %s", e.Field, e.Message)
}

// Wrap errors with context using %w
func GetUser(id string) (*User, error) {
    user, err := db.Find(id)
    if err != nil {
        return nil, fmt.Errorf("GetUser(%s): %w", id, err)
    }
    if user == nil {
        return nil, fmt.Errorf("GetUser(%s): %w", id, ErrNotFound)
    }
    return user, nil
}

// Check wrapped errors with errors.Is and errors.As
func HandleRequest(id string) error {
    user, err := GetUser(id)
    if err != nil {
        if errors.Is(err, ErrNotFound) {
            return writeNotFound()
        }
        var validErr *ValidationError

From dallay/agents-skills, MIT.

More from dallay/agents-skills