golang

Enforce structured Go development guidelines across code creation and modification.

Updated Apr 16, 2026
One-click install
npx skills add https://github.com/HadiCherkaoui/opencode-config --skill golang-hadicherkaoui
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: golang
Source: https://github.com/HadiCherkaoui/opencode-config/tree/main/skills/golang
Command: npx skills add https://github.com/HadiCherkaoui/opencode-config --skill golang-hadicherkaoui

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Go development often suffers from inconsistent style, naming, error handling, and architectural drift across teams, leading to brittle code and higher maintenance costs. This Skill unit provides a structured, modular approach to enforce Go best practices by organizing rules into sub-skills that can be selectively loaded.

Core Features & Use Cases

  • Centralized Go guidelines covering core style, naming, error handling, concurrency, interfaces, and testing.
  • Load only the applicable sub-skills before writing or editing code to guide decisions and ensure consistent outcomes.
  • Supports faster onboarding and code reviews by providing clear, actionable rules and checklists.

Quick Start

Load the relevant sub-skills and apply gofmt before writing any Go code.

Frequently Asked Questions about golang

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

FAQPage Schema
How do I enforce consistent Go coding guidelines across my team?

To enforce consistent Go coding guidelines, load specific sub-skills for naming, error handling, and concurrency before writing code. This structured approach ensures adherence to best practices and prevents architectural drift across team projects.

What is the best way to manage context propagation in Go development?

The best way to manage context propagation in Go is to pass context as the first parameter and avoid storing it in structs. Following this standard prevents context lifecycle issues and ensures reliable cancellation signals across concurrent operations.

How do I structure Go error handling and concurrency rules for a new project?

Structuring Go error handling and concurrency rules involves selectively loading modular sub-skills before code creation. This provides actionable checklists and specific guidelines, ensuring standardized outcomes for complex concurrent processes.

Do I need to apply gofmt formatting before writing Go code?

Yes, you need to apply gofmt formatting before writing Go code. Applying gofmt standardizes syntax formatting, ensuring that all generated code complies with baseline style requirements and reduces unnecessary review friction.

Can I use these Go coding standards for automated code reviews?

Yes, you can use these Go coding standards for automated code reviews. The centralized guidelines and modular rule checklists support faster onboarding and provide clear, actionable criteria for validating code modifications.

Why does my Go code suffer from architectural drift during modifications?

Go code suffers from architectural drift during modifications when inconsistent styles are applied without structured guidelines. Loading applicable sub-skills before editing enforces standardized error handling and naming conventions, preventing brittle code.