golang-samber-oops

Generate samber/oops error builders with stack traces and context.

1|Updated Apr 4, 2026
One-click install
npx skills add https://github.com/Jylhis/claude-marketplace --skill golang-samber-oops-jylhis
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: golang-samber-oops
Source: https://github.com/Jylhis/claude-marketplace/tree/main/plugins/golang-dev/skills/golang-samber-oops
Command: npx skills add https://github.com/Jylhis/claude-marketplace --skill golang-samber-oops-jylhis

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Many Go applications lack rich error context, making debugging and monitoring difficult.

Core Features & Use Cases

  • Builder Pattern: Fluent chaining to add domains, tags, codes, and attributes.
  • Stack Traces & Context: Automatic stack capture and propagation through contexts.
  • Public vs Technical Messages: Separate user‑facing messages from detailed error info.
  • Panic Recovery: Convert panics into structured errors with builder. Use case: In a microservice, wrap database errors with domain, tags, and request info to enable observability.

Quick Start

Ask the skill to generate a samber/oops error builder for a function that accesses a database.

Frequently Asked Questions about golang-samber-oops

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

FAQPage Schema
How do I add structured context to Go error handling across microservices?

Structured error handling in Go uses a builder pattern to attach domains, tags, and attributes to errors. This enables rich context propagation across service layers for better observability and debugging.

Can I separate user-facing error messages from technical details in Go?

Yes, structured error handling allows you to define public messages separately from technical error information. This ensures user-facing responses remain clean while retaining detailed diagnostic data for monitoring.

What is the best way to capture stack traces for Go application errors?

Capturing stack traces for Go errors is handled automatically by structured error handling libraries. They propagate context through the call stack, providing detailed trace data for pinpointing failure origins.

How do I convert Go panics into structured errors?

You can convert Go panics into structured errors using panic recovery features within the error builder. This captures the panic context and wraps it into a structured error with attributes for logging.

Does structured error handling in Go integrate with logging and monitoring tools?

Structured error handling integrates with logging and monitoring tools by injecting attributes and context into errors. This allows observability platforms to query and filter errors by domain, tags, or request info.

When do I need fluent builder chaining for Go error handling?

Fluent builder chaining is needed when wrapping complex errors in Go microservices. It lets you progressively add domains, codes, and attributes to errors, ensuring rich context is attached before propagating them.