Skill UI

This skill acts as a comprehensive Go modernization engineer, scanning entire codebases to update outdated patterns, deprecated APIs, and standard library usage. It utilizes multi-agent orchestration to check language features, testing patterns, and tooling/infra, ensuring the codebase adheres to the latest Go idioms for maximum safety and readability. Ideal for CI/CD pipelines or large-scale code reviews.

A comprehensive guide to Go (Golang) naming conventions. It covers best practices for packages, structs, interfaces, constants, errors, and more. Use this skill when writing, reviewing, or refactoring Go code to ensure idiomatic and clear naming that follows Go standards (e.g., MixedCaps, constructor rules, error handling).

This skill provides comprehensive best practices for monitoring Go services in production. It covers the five critical pillars of observability: structured logging (slog), Prometheus metrics, OpenTelemetry distributed tracing, continuous profiling, and Real User Monitoring (RUM). Use this skill to proactively instrument new features, set up advanced alerting, correlate logs with traces, and ensure full visibility into system health and user experience.

A comprehensive guide and skill set for optimizing Go (Golang) application performance. It establishes a core philosophy of profiling before optimizing, focusing on reducing allocations, improving CPU efficiency, and addressing structural anti-patterns. Provides systematic modes for deep review (hot path, architecture review) and follows an iterative methodology (Benchmark -> Diagnose -> Improve -> Compare) to ensure measurable and stable performance gains.

This skill acts as an expert guide for selecting the optimal Go libraries and frameworks. It prioritizes production readiness, simplicity, and leveraging the standard library first. Use it when comparing alternative dependencies, vetting core functionality (web, database, testing), or choosing the best architectural approach for a new Go project.

A comprehensive guide for structuring robust Go applications, covering best practices for new projects, from CLI tools to complex microservices and monorepos. It details directory conventions (cmd, internal, pkg), naming rules, adopting 12-Factor App principles, and choosing appropriate architectures (Clean, DDD, Hexagonal).

This skill guides developers in writing robust and defensive Go code. It addresses common pitfalls that lead to runtime panics and silent data corruption, such as nil map writes, slice backing array aliasing, silent numeric truncation (int64 to int32), and inaccurate float comparisons. Use this when designing highly reliable Go systems that must withstand typical programmer errors and maintain data integrity.

A comprehensive guide and skill set for implementing dependency injection in Go using the samber/do toolkit. It covers core concepts like defining services (Lazy, Eager, Transient), managing service lifetimes, handling dependencies via provider functions, and organizing large codebases using package-level injection.

A generic, type-safe in-memory caching library for Go (Go 1.22+). It offers advanced features like nine specialized eviction algorithms (LRU, LFU, W-TinyLFU), Time-To-Live (TTL), read-through loaders, and Prometheus metrics. This skill helps developers design robust caching layers, optimize performance by selecting the correct eviction policy based on access patterns, and manage cache capacity effectively.

A comprehensive, generics-first utility library designed for Go developers who prefer declarative, functional programming patterns over manual loops. It provides 500+ type-safe functions for common data transformations (Map, Filter, Reduce, GroupBy, etc.) on slices, maps, and strings. By defaulting to immutable operations, it ensures thread safety and predictable state changes. The library also offers specialized packages (lop, lom, loi) to address performance bottlenecks, such as CPU-bound parallel processing or lazy evaluation, allowing engineers to choose the optimal approach for their c...

A library providing type-safe monadic abstractions for Go, including Option, Result, and Either. It allows developers to eliminate nil pointer risks and manage complex error handling using composable, functional pipelines, significantly improving code robustness and readability in Go applications.

samber/oops is a robust library that transforms standard Go error handling by adding crucial structured context. Instead of generic error messages, it allows developers to attach key-value attributes, stack traces, error codes, and user-facing messages directly to the error object. This is essential for modern microservices, allowing APM tools (Datadog, Sentry) and on-call engineers to diagnose failures accurately by understanding the full context of the failure, such as the domain, user ID, and specific query that failed.