skills.rest
RogerioSobrinho
RogerioSobrinhoCOMMUNITY
Explore all skills by this author →
GitHub

golang-patterns

Provides Go design patterns for packages, errors, concurrency, and testing.

Updated Mar 26, 2026
Search Tags:#testing#architecture#concurrency#golang#patterns#go#error-handling
One-click install
npx skills add https://github.com/RogerioSobrinho/codeme-copilot --skill golang-patterns-rogeriosobrinho
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: golang-patterns
Source: https://github.com/RogerioSobrinho/codeme-copilot/tree/main/skills/golang-patterns
Command: npx skills add https://github.com/RogerioSobrinho/codeme-copilot --skill golang-patterns-rogeriosobrinho

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Go developers often struggle to design idiomatic packages, handle errors consistently, and structure concurrent code. This skill collects proven patterns from the Go ecosystem to elevate code quality across packages and services.

Core Features & Use Cases

  • Package Design: one package per directory; keep surfaces small.
  • Error Handling: treat errors as values, wrap with context, and use sentinel errors.
  • Interfaces: favor small interfaces and constructor-based wiring.
  • Concurrency: use goroutines and errgroup only when necessary, with proper context.
  • Context: pass context.Context to I/O and blocking operations.
  • Testing & Naming: focus tests, naming conventions, and minimal interfaces.
  • go.mod practices: specify Go version and tidy dependencies.

Quick Start

Start by applying these patterns to a new Go module to enforce idiomatic structure and robust error handling.

Frequently Asked Questions about golang-patterns

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I handle errors consistently in Go microservices?▼

Idiomatic Go error handling treats errors as values, wraps them with context for tracing, and uses sentinel errors for expected failure states to ensure robust microservices.

What's the best way to structure Go packages for production services?▼

Structure Go packages by placing one package per directory and keeping public surfaces small, applying proven layout patterns to elevate code quality across production services.

How do I manage concurrency with goroutines and context in Go?▼

Manage Go concurrency by using goroutines and errgroup only when necessary, always passing context.Context to I/O and blocking operations to enable proper cancellation.

When should I define small interfaces in Go?▼

Define small Go interfaces when designing package APIs to favor constructor-based wiring and minimal dependencies, ensuring robust and maintainable code architectures.

How do I structure testing practices for Go libraries?▼

Structure Go testing practices by focusing tests on behavior, applying naming conventions, and using minimal interfaces to verify library functions and package logic effectively.

Related Skills

Explore More Software Engineering Skills→
motlinmotlin
14

git-workflow

Standardize git commits, rebasing, conflict resolution, and branch management.

Community
Basic
carrot-hu23carrot-hu23
905

golang-patterns

Provide idiomatic Go patterns for writing, reviewing, and refactoring services and libraries.

Community
Intermediate
itou-daikiitou-daiki

golang-patterns

Apply idiomatic Go patterns for robust, maintainable application design.

Community
Advanced
ysyecustysyecust
40

golang-patterns

Reference idiomatic Go patterns for error handling, interfaces, and concurrency.

Community
Basic