One-click install
npx skills add https://github.com/BizShuk/gosdk --skill golang-code-quality-bizshuk
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: golang-code-quality
Source: https://github.com/BizShuk/gosdk/tree/main/skills/golang-code-quality
Command: npx skills add https://github.com/BizShuk/gosdk --skill golang-code-quality-bizshuk

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Go codebases often suffer from inconsistent quality, non-idiomatic patterns, and unmaintainable package structures that slow development, introduce bugs, and complicate onboarding for new engineers. This skill provides a structured, principle-driven workflow to eliminate these issues across all Go code writing, review, and refactoring tasks.

Core Features & Use Cases

  • SOLID Principle Enforcement: Tailored guidance for applying SOLID principles via Go's composition model (no inheritance required) to reduce coupling and improve code extensibility.
  • Layered Architecture Validation: Enforces MVC-style package boundaries to eliminate cyclic imports, misplaced business logic, and other architectural anti-patterns.
  • Standardized Conventions: Unified rules for error handling, context propagation, dependency injection, package naming, and code structure that align with official Go community best practices.
  • Use Case: For example, when reviewing a pull request for a new Go microservice, use this skill to catch violations like business logic in the service layer, fat interfaces, and missing context propagation before code is merged.

Quick Start

Use the golang-code-quality skill to review the Go code in the ./pkg/handler directory for SOLID violations and layered architecture issues.

Frequently Asked Questions about golang-code-quality

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

FAQPage Schema
How do I enforce idiomatic Go code quality during code review?

To enforce idiomatic Go code quality, review pull requests for SOLID violations, misplaced business logic, fat interfaces, and missing context propagation to ensure code remains simple to read and hard to misuse.

What is the best way to apply SOLID principles in Go without inheritance?

Applying SOLID principles in Go uses the composition model instead of inheritance, reducing coupling and improving code extensibility by enforcing structured, principle-driven dependency injection and interface boundaries.

How do I fix cyclic imports and unmaintainable package structures in a Go codebase?

Fix cyclic imports and unmaintainable package structures by validating MVC-style layered architecture boundaries, eliminating misplaced business logic, and standardizing package naming conventions across backend services.

How do I standardize error handling and context propagation in Go microservices?

Standardize error handling and context propagation by applying unified rules that align with official Go community best practices, ensuring your backend services remain simple to read and easy to extend.

Can I use this to refactor existing Go shared libraries and CLI tools?

Yes, you can refactor existing Go codebases for shared libraries and CLI tools by validating layered architecture, catching SOLID violations, and enforcing dependency injection best practices during the refactoring process.

Why does my Go codebase have non-idiomatic patterns and fat interfaces?

Non-idiomatic patterns and fat interfaces occur when Go code lacks structured SOLID enforcement, which can be resolved by applying Go-adapted composition models and standardized architectural boundaries.