К основному содержанию
скилл CX Codex

golang-idioms — скилл для Claude Code: что делает и как установить

Скилл golang-idioms для Claude Code задаёт идиоматичные паттерны Go для обработки ошибок, конкурентности и тестирования.

Apache-2.0 ★ 2 858 обновлён 2026-05-12

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add rohitg00/awesome-claude-code-toolkit --skill golang-idioms -a claude-code
Открыть на GitHub

Что делает golang-idioms

Скилл задаёт для Claude Code правила написания кода на Go. Внутри собраны готовые шаблоны для интерфейсов по принципу «принимай интерфейс, возвращай структуру», обработка ошибок через обёртывание с %w и вызов сторожевых ошибок через errors.Is. Для конкурентности описаны паттерны Worker Pool и Fan-out/Fan-in с обязательным контролем завершения горутин через sync.WaitGroup и каналы.

В блок тестирования входят табличные тесты, очистка ресурсов через t.Cleanup и разметка вспомогательных функций с помощью t.Helper. Скилл прямо запрещает сохранять контекст внутри структур и вызывать panic в библиотечном коде: любая операция ввода-вывода обязана принимать context.Context первым параметром.

Какие задачи решает

  • оформить табличные тесты с хелперами на Go
  • настроить пул горутин с корректной отменой через контекст
  • спроектировать компактные интерфейсы на стороне потребителя
  • обернуть ошибки с сохранением контекста для errors.Is

Примеры запросов агенту

  • Напиши Worker Pool для обработки очереди задач по правилам golang-idioms
  • Сделай табличный тест валидатора email с использованием t.Helper и t.Cleanup
  • Отрефактори сервис: вынеси зависимости в интерфейсы и добавь обёртывание ошибок через %w

Как установить golang-idioms

1Через Skills CLI (Vercel)

npx skills add rohitg00/awesome-claude-code-toolkit --skill golang-idioms -a claude-code

2Вручную: положить файлы

~/.claude/skills/golang-idioms/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/golang-idioms/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы о golang-idioms

Как установить golang-idioms в Claude Code?

Выполните команду npx skills add rohitg00/awesome-claude-code-toolkit --skill golang-idioms -a claude-code в терминале или сохраните файл в ~/.claude/skills/golang-idioms/SKILL.md.

Что делает golang-idioms?

Скилл учит агента общепринятым практикам Go: проектированию структур с полезным нулевым значением, безопасному управлению горутинами, распространению контекста и работе со slog.

Как скилл требует работать с контекстом?

Контекст передаётся исключительно первым аргументом функций с вводом-выводом. Хранить context.Context в полях структур правила запрещают.

Исходный текст

SKILL.md · Apache-2.0
---
name: golang-idioms
description: Idiomatic Go patterns for error handling, interfaces, concurrency, testing, and module management
---

# Go Idioms

## Error Handling

```go
// Return errors, never panic in library code
func LoadConfig(path string) (Config, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return Config{}, fmt.Errorf("reading config %s: %w", path, err)
    }

    var cfg Config
    if err := json.Unmarshal(data, &cfg); err != nil {
        return Config{}, fmt.Errorf("parsing config: %w", err)
    }

    return cfg, nil
}
```

Rules:
- Always wrap errors with context using `fmt.Errorf("context: %w", err)`
- Use `%w` to allow callers to use `errors.Is` and `errors.As`
- Handle errors at the appropriate level; do not log and return the same error
- Define sentinel errors for expected conditions

```go
var (
    ErrNotFound    = errors.New("not found")
    ErrUnauthorized = errors.New("unauthorized")
)

func GetUser(id string) (User, error) {
    user, ok := store[id]
    if !ok {
        return User{}, fmt.Errorf("user %s: %w", id, ErrNotFound)
    }
    return user, nil
}

// Caller
user, err := GetUser(id)
if errors.Is(err, ErrNotFound) {
    http.Error(w, "user not found", http.StatusNotFound)
    return
}
```

## Interface Design

```go
// Keep interfaces small (1-3 methods)
type Reader interface {
    Read(p []byte) (n int, err error)
}

type UserStore interface {
    GetUser(ctx context.Context, id string) (User, error)
    CreateUser(ctx context.Context, u User) error
}

// Accept interfaces, return structs
func NewService(store UserStore, logger *slog.Logger) *Service {
    return &Service{store: store, logger: logger}
}
```

Rules:
- Define interfaces where they are used (consumer side), not where they are implemented
- Prefer small, composable interfaces over large ones
- Use `io.Reader`, `io.Writer`, `fmt.Stringer` from the standard library
- An interface with one method should be named after the method + `er` suffix

## Goroutine and Channel Patterns

### Worker Pool
```go
func process(ctx context.Context, jobs <-chan Job, workers int) <-chan Result {
    results := make(chan Result, workers)
    var wg sync.WaitGroup

    for range workers {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {
                select {
                case <-ctx.Done():
                    return
                case results <- job.Execute():
                }
            }
        }()
    }

    go func() {
        wg.Wait()
        close(results)
    }()

    return results
}
```

### Fan-out/Fan-in
```go
func fanOut[T, R any](ctx context.Context, items []T, fn func(T) R, concurrency int) []R {
    sem := make(chan struct{}, concurrency)
    results := make([]R, len(items))
    var wg sync.WaitGroup

    for i, item := range items {
        wg.Add(1)
        sem <- struct{}{}
        go func() {
            defer func() { <-sem; wg.Done() }()
            results[i] = fn(item)
        }()
    }

    wg.Wait()
    return results
}
```

Rules:
- Always pass `context.Context` as the first parameter
- Always ensure goroutines can be stopped (via context cancellation or channel close)
- Use `sync.WaitGroup` to wait for goroutine completion
- Use buffered channels when producer and consumer run at different speeds
- Never start a goroutine without knowing how it will stop

## Context Propagation

```go
func (s *Service) HandleRequest(ctx context.Context, req Request) (Response, error) {
    ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
    defer cancel()

    user, err := s.store.GetUser(ctx, req.UserID)
    if err != nil {
        return Response{}, fmt.Errorf("getting user: %w", err)
    }

    ctx = context.WithValue(ctx, userKey, user)
    return s.processRequest(ctx, req)
}
```

Rules:
- Pass context as the first parameter of every function that does I/O
- Use `context.WithTimeout` or `context.WithDeadline` for all external calls
- Always `defer cancel()` after creating a cancellable context
- Use `context.WithValue` sparingly (request-scoped values only: trace IDs, auth info)
- Never store context in a struct

## Table-Driven Tests

```go
func TestValidateEmail(t *testing.T) {
    tests := []struct {
        name  string
        email string
        want  bool
    }{
        {"valid email", "[email protected]", true},
        {"missing @", "userexample.com", false},
        {"empty string", "", false},
        {"multiple @", "user@@example.com", false},
        {"valid with subdomain", "[email protected]", true},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got := ValidateEmail(tt.email)
            if got != tt.want {
                t.Errorf("ValidateEmail(%q) = %v, want %v", tt.email, got, tt.want)
            }
        })
    }
}
```

### Test Helpers
```go
func newTestServer(t *testing.T) *httptest.Server {
    t.Helper()
    handler := setupRoutes()
    srv := httptest.NewServer(handler)
    t.Cleanup(srv.Close)
    return srv
}

func assertEqual[T comparable](t *testing.T, got, want T) {
    t.Helper()
    if got != want {
        t.Errorf("got %v, want %v", got, want)
    }
}
```

Use `t.Helper()` in all test utility functions. Use `t.Cleanup()` instead of `defer` for test resource cleanup. Use `testdata/` directory for test fixtures.

## Module Management

```
go.mod structure:
module github.com/org/project

go 1.23

require (
    github.com/lib/pq v1.10.9
    golang.org/x/sync v0.7.0
)
```

Commands:
```bash
go mod tidy          # remove unused, add missing
go mod verify        # verify checksums
go list -m -u all    # check for updates
go get -u ./...      # update all dependencies
go mod vendor        # vendor dependencies (optional)
```

Use `go mod tidy` before every commit. Pin major versions. Review changelogs before updating.

## Zero-Value Design

Design types so their zero value is useful:

```go
// sync.Mutex zero value is an unlocked mutex (ready to use)
var mu sync.Mutex

// bytes.Buffer zero value is an empty buffer (ready to use)
var buf bytes.Buffer
buf.WriteString("hello")

// Custom types: make zero value meaningful
type Server struct {
    Addr    string        // defaults to ""
    Handler http.Handler  // defaults to nil
    Timeout time.Duration // defaults to 0 (no timeout)
}

func (s *Server) ListenAndServe() error {
    addr := s.Addr
    if addr == "" {
        addr = ":8080" // useful default
    }
    handler := s.Handler
    if handler == nil {
        handler = http.DefaultServeMux
    }
    // ...
}
```

Rules:
- Prefer structs with meaningful zero values over constructors
- Use pointer receivers when the method modifies the receiver
- Use value receivers when the method only reads
- Never export fields that users should not set directly; use constructor functions

## Structured Logging

```go
import "log/slog"

logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
    Level: slog.LevelInfo,
}))

logger.Info("request handled",
    slog.String("method", r.Method),
    slog.String("path", r.URL.Path),
    slog.Int("status", status),
    slog.Duration("latency", time.Since(start)),
)
```

Use `log/slog` (standard library, Go 1.21+). Use structured fields, never string interpolation. Include request ID, user ID, and operation name in every log entry.

## Common Anti-Patterns

- Returning `interface{}` / `any` instead of concrete types
- Using `init()` for complex setup (makes testing hard)
- Ignoring errors with `_` without comment
- Using goroutines without lifecycle management
- Mutex contention from overly broad lock scope
- Channel misuse: prefer mutexes for simple shared state
- Naked returns in functions longer than a few lines

© rohitg00 · Apache-2.0 · rohitg00/awesome-claude-code-toolkit

Похожие скиллы

Все скиллы по теме «Языки программирования» →
golang-pro https://github.com/Jeffallan Скилл golang-pro для ИИ-агента, который пишет идиоматичный Go: горутины, каналы, gRPC, профилирование через pprof и табличные тесты. CX Codex +1 19 800установок golang-master Pedro Nauck Скилл golang-master для Claude Code помогает писать и проверять Go-код. Подключается к задачам об ошибках, конкурентности, тестах, производительности и структуре модулей. CX Codex +1 115установок golang-concurrency samber Скилл golang-concurrency задаёт правила для конкурентного кода на Go: жизненный цикл горутин, каналы и select, мьютексы, errgroup, singleflight, воркер-пулы и fan-out/fan-in пайплайны. CX Codex +1 44 500установок golang-context samber Скилл golang-context для идиоматичной работы с context.Context в Go: проброс через слои, отмена, таймауты и значения запроса. Пригодится при проектировании API и отладке утечек контекста. CX Codex +1 43 600установок golang saisudhir14 Скилл golang для Claude Code задаёт агенту правила Go: обработку ошибок, конкурентность, нейминг, тесты и дженерики. Помогает писать и ревьюить Go-код. CX Codex +1 535установок golang-backend-development manutej Скилл golang-backend-development добавляет в Claude Code шаблоны разработки на Go: от многопоточности на горутинах и каналах до синхронизации памяти и цикла обработки запросов. CX Codex +1 1 400установок

Из того же набора178

Весь набор →
technology-scout Субагент technology-scout анализирует новые технологии, проводит сравнение build-vs-buy и оценивает решения поставщиков. Помогает принять обоснованное решение о внедрении или отказе от технологии. CX Codex ★ 2 858звёзд репо react-patterns Скилл react-patterns для Claude Code собирает шаблоны React 19 для серверных компонентов, серверных действий, Suspense и управления состоянием. CX Codex +1 ★ 2 858звёзд репо data-engineering Скилл data-engineering для Claude Code помогает проектировать ETL-пайплайны, хранилища и обработку данных в Apache Spark. Помогает продумать проверки качества и схему витрины данных. CX Codex +1 ★ 2 858звёзд репо python-best-practices Скилл python-best-practices подсказывает Claude Code писать Python на современном синтаксисе: тайп-хинты, dataclasses, async, структура проекта и тесты на pytest. CX Codex +1 ★ 2 858звёзд репо workflow-optimizer Плагин workflow-optimizer для Claude Code анализирует рабочий процесс разработки и предлагает, как его улучшить. Помогает разобраться, где в проекте можно изменить порядок работы. ★ 2 858звёзд репо web-dev Плагин web-dev для Claude Code автоматизирует создание полнофункциональных веб-приложений: генерирует структуру проекта, компоненты и страницы с одной команды. ★ 2 858звёзд репо visual-regression Плагин visual-regression проводит визуальное регрессионное тестирование интерфейса через сравнение скриншотов. Помогает отслеживать непреднамеренные сдвиги вёрстки при изменении кода. ★ 2 858звёзд репо vision-specialist Анализирует изображения, извлекает текст и интерпретирует скриншоты. Запускается по команде /vision-specialist:analyze или при обращении к визуальному контенту. ★ 2 858звёзд репо

Спонсоры проекта

Компании, которые помогают держать аналитику открытой