golang-pro

Build idiomatic Go workflows for concurrency, microservices, generics, and testing.

Updated May 28, 2026
One-click install
npx skills add https://github.com/haryelramalho/skills --skill golang-pro-haryelramalho
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: golang-pro
Source: https://github.com/haryelramalho/skills/tree/main/skills/curated/golang-pro
Command: npx skills add https://github.com/haryelramalho/skills --skill golang-pro-haryelramalho

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps you design, implement, and validate production-grade Go code without losing time to inconsistent concurrency patterns, weak abstractions, or brittle tests.

Core Features & Use Cases

  • Concurrent Programming: Build goroutine and channel workflows with clear cancellation, bounded lifecycles, and safe synchronization.
  • Microservices and APIs: Structure Go services for REST or gRPC, with idiomatic interfaces, context propagation, and explicit error handling.
  • Performance and Quality: Improve runtime behavior with profiling and benchmarks, and keep code reliable with table-driven tests, race detection, linting, and documentation.
  • Use Case: Use this Skill when creating a worker pool, refactoring a service boundary, tuning a slow endpoint, or setting up a testable Go project layout.

Quick Start

Ask the skill to design, implement, and test a Go feature using idiomatic concurrency, clean interfaces, and table-driven validation.

Frequently Asked Questions about golang-pro

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

FAQPage Schema
How do I build safe concurrency patterns with goroutines and channels in Go?

To build safe Go concurrency, orchestrate goroutines and channel pipelines with clear context propagation, explicit error handling, bounded lifecycles, and race-safe synchronization. This approach prevents data races and ensures clean cancellation for concurrent workflows.

What is the best way to structure a Go microservice for gRPC or REST?

The best way to structure Go microservices is by applying idiomatic interfaces, explicit error handling, and strict context propagation across service boundaries. This ensures reliable gRPC or REST API communication and maintainable project layouts.

How do I set up table-driven tests and race detection for a Go project?

Set up table-driven tests in Go by defining structured test cases and executing them with the standard testing package. Enforce race-safe validation and linting requirements to catch concurrent data races and ensure reliable code coverage.

Can I use Go generics to improve application type safety and performance?

Yes, you can use Go generics to design strongly-typed, reusable components without sacrificing runtime performance. Combined with profiling and benchmarks, generics help optimize slow endpoints and ensure type-safe application workflows.

Why does my Go application have slow endpoints and how can I profile them?

Your Go application endpoints may be slow due to inefficient concurrency or memory allocations. Use pprof profiling and benchmarks to identify bottlenecks, tune runtime behavior, and validate performance improvements in your code.

When do I need explicit context propagation in Go concurrent programming?

You need explicit context propagation in Go whenever managing goroutine lifecycles, handling API requests, or orchestrating channel pipelines. It ensures safe cancellation, timeouts, and race-free state synchronization across concurrent boundaries.