Skill UI

A comprehensive guide for developing robust, Unix-native Command Line Interfaces (CLIs) using Go. It details best practices for command structure, flag handling, configuration layering (Viper), and argument validation using Cobra. Learn how to build, extend, and review professional-grade Go tools that behave predictably in shell environments.

A comprehensive guide for writing, reviewing, and auditing concurrent Go code. It covers core principles of structured concurrency, including proper resource management for goroutines, safe use of channels, mutexes, and advanced synchronization primitives like errgroup and singleflight. Essential for avoiding common issues like goroutine leaks, race conditions, and context propagation failures.

This comprehensive guide dives deep into the internals of core Go data structures, including slices, maps, and arrays. It details optimal usage patterns—such as preallocation, capacity growth mechanics, and choosing between containers like strings.Builder and bytes.Buffer. Essential for writing high-performance, memory-efficient, and idiomatic Go code.

A comprehensive guide covering idiomatic Go error handling. It teaches best practices for creating, wrapping, inspecting, and logging errors, including using `errors.Is`, `errors.As`, `errors.Join`, structured logging (`slog`), and advanced patterns like sentinel errors and stack tracing. Use this skill when implementing or reviewing error logic in Go applications to ensure reliability and debuggability.

A comprehensive skill for instrumenting Go services to achieve full production observability. It covers best practices for structured logging (slog), implementing Prometheus metrics, setting up OpenTelemetry distributed tracing, continuous profiling with pprof, and tracking user experience (RUM). Use this skill when proactively monitoring, diagnosing issues, or migrating services to ensure every feature is fully observable.

A type-safe dependency injection toolkit for Go, enabling robust and maintainable application architecture. It manages service containers, handling service lifecycles (Lazy, Eager, Transient), scoped services, and dependency resolution. Ideal for refactoring manual constructor injection into a structured DI system in Go projects.

samber/oops provides a structured, context-rich replacement for standard Go error handling. It allows engineers to attach critical metadata—such as domain, user ID, stack traces, error codes, and request details—directly to the error object. This ensures that variable data travels with the error through the call stack, enabling advanced APM tools (like Sentry or Datadog) to group and diagnose issues accurately, treating errors as structured, actionable data.

This skill provides comprehensive composable handlers for Golang structured logging using the samber/slog ecosystem. It enables developers to build robust, multi-stage log pipelines by integrating sampling for throughput control, formatters for PII scrubbing, complex routers, and multiple backend sinks (e.g., Sentry, Loki, Datadog). It is essential for building high-observability Go applications.

A comprehensive skill set for senior Go security engineers, providing structured methodologies for identifying and mitigating vulnerabilities. It teaches defense-in-depth principles, utilizes Threat Modeling (STRIDE), and scores risks using DREAD. Modes include detailed Review (PR security checks), full Audit (parallel vulnerability scanning), and Coding (secure implementation). Essential for auditing, reviewing, or developing any Go application that handles sensitive data.

Provides a minimal skill definition that only includes the required fields, showing how to structure SKILL.md for quick testing or deployment of basic examples.

Example skill that walks through the Anthropic SKILL.md structure, showcasing when to load it, how to author steps, and how to reference bundled resources for skill creation.

This CLI alias implements the PUA Loop protocol, designed for running structured, iterative verification cycles. It helps developers set up and manage complex coding tasks that require explicit verification commands and defined stop conditions. It serves as a powerful wrapper for AI coding assistants like Codex/Claude, ensuring robust and traceable development workflows.