Skill UI

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.

This comprehensive skill provides a senior Go security engineer persona, guiding users through rigorous security practices for Golang development and code auditing. It covers threat modeling (STRIDE), vulnerability analysis (DREAD), secure development principles, and specialized modes like Review and Audit to detect issues such as injection, crypto flaws, and authorization weaknesses.

Curated guide providing Go resources, newsletters, communities, blogs, and key developers to follow so you can discover libraries, track releases, and learn the language consistently.

This comprehensive guide deep dives into `stretchr/testify`, the essential tool for writing robust and readable unit tests in Go. It covers the crucial differences between `assert` and `require` for controlled failure handling, implementing sophisticated mocks, and managing test lifecycles using suites. It is perfect for developers aiming to write maintainable, self-documenting, and reliable test code in Go.

Guides Go developers through struct/interface design best practices, covering interface segregation, composition, dependency injection, type assertions, and choosing pointer vs value receivers to keep APIs clear and testable.

A systematic guide for debugging complex issues in Go applications, including crashes, deadlocks, concurrency errors, and performance bottlenecks. This skill teaches the 'Golden Rules' of debugging: reproducing bugs, isolating variables, and finding the true root cause rather than applying symptom fixes. It covers advanced techniques using pprof for profiling, the Delve debugger (dlv), and Go's built-in race detector, providing a structured methodology for professional software development.

Comprehensive Go testing guidance that spans table-driven subtests, testify suites, mocking, unit/integration tests, benchmarks, coverage, fuzzing, goleak leak detection, snapshot checks, and GitHub Actions CI to keep production suites reliable.

A comprehensive guide for building high-performance GraphQL servers using Golang. This skill covers everything from choosing between gqlgen and graphql-go, designing robust schemas (nullability, pagination), implementing clean resolver patterns, and critically, preventing N+1 database query issues using DataLoaders. Essential for backend engineers building enterprise-grade APIs.

A reflection-based Dependency Injection (DI) container for Go. It is designed to facilitate the wiring of complex object graphs during application startup. Developers can use `Provide` to register constructors and manage dependencies using structures like `dig.In` and `dig.Out`. It supports named values, value groups, and interfacing, making it ideal for building robust, scalable, and highly testable Go applications and libraries.

A robust application framework for Go, built on the uber-go/dig container. It provides advanced features essential for long-running services, including structured dependency injection, explicit lifecycle hooks (OnStart/OnStop), modular composition, and signal-aware graceful shutdown handling. Ideal for building robust daemons, HTTP servers, and background workers.

A robust toolkit for managing dependencies in Go. It uses code generation to resolve the entire dependency graph at compile time, eliminating the need for runtime containers or reflection. This ensures that all missing dependencies are caught during the build step (`wire ./...`), leading to highly robust, predictable, and type-safe applications. Ideal for building large-scale, enterprise Go microservices.

This skill guides the development of robust, Unix-like Command Line Interfaces (CLIs) in Go using the industry-standard `cobra` library. It covers the entire lifecycle of a CLI application, including command tree setup, managing persistent vs. local flags, advanced positional argument validation, and utilizing the full execution hook chain (RunE). Ideal for engineers adopting or maintaining sophisticated Go CLI projects.