go-core

Review Go packages for API design, concurrency safety, and error handling.

1|Updated Mar 22, 2026

Search Tags:#context #interfaces #concurrency #go #code-review #api-design #error-wrapping

Ready to run

npx skills add https://github.com/caraya/agent-skills --skill go-core-caraya

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: go-core
Source: https://github.com/caraya/agent-skills/tree/main/skills/go-core
Command: npx skills add https://github.com/caraya/agent-skills --skill go-core-caraya

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Helps Go teams design robust packages with clean API boundaries, safe concurrency, and idiomatic error handling.

Core Features & Use Cases

API and package design: minimal interfaces with explicit boundaries.
Concurrency and context: correct use of goroutines, channels, and cancellation propagation.
Error handling: return wrapped errors with context to aid debugging.
Use Case: conduct a code review on a Go microservice to verify interface boundaries, context usage, and error wrapping.

Quick Start

Review a Go package to ensure safe concurrency and idiomatic error handling.

Frequently Asked Questions about go-core

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

FAQPage Schema

How do I review Go code for safe concurrency and idiomatic error handling?▼

Reviewing Go code for safe concurrency and idiomatic error handling involves checking goroutine cancellation, context propagation, and wrapped errors. This process verifies interface boundaries and ensures backend services follow safe concurrency patterns.

What is the best way to design minimal Go interfaces for package boundaries?▼

Designing minimal Go interfaces for package boundaries requires defining explicit, narrow contracts that consumers need. This approach keeps API boundaries clean and prevents leaking internal implementation details into the public package API.

Why does context cancellation matter in Go microservices?▼

Context cancellation matters in Go microservices because it propagates shutdown signals and deadlines across goroutines. Correct context usage prevents resource leaks by ensuring concurrent operations halt cleanly when a request is canceled.

How do I wrap errors with context in Go to aid debugging?▼

Wrapping errors with context in Go involves using the standard error wrapping mechanisms to add stack traces or operational details. This contextual error wrapping preserves the original error chain while providing specific debugging information for backend services.

Can I use this approach to review an existing Go microservice codebase?▼

Yes, you can review an existing Go microservice codebase by applying these patterns to verify interface boundaries, context usage, and error wrapping. This ensures the existing backend services maintain robust package design and safe concurrency.