Skill UI

A type-safe, generics-first implementation of ReactiveX for Go. It manages complex asynchronous, event-driven pipelines, providing core features like automatic backpressure, comprehensive error propagation, and Go context integration. Use this library when handling infinite streams, real-time data processing, or building advanced event-driven architectures beyond simple channel usage.

A comprehensive set of composable handlers for building robust structured logging pipelines in Go (Go 1.21+). This library allows developers to control the entire log flow: implementing sampling for throughput control, formatting for data masking (PII), and sophisticated routing (Fanout, Router, Pipe) to multiple backend sinks like Sentry, Loki, Datadog, and others. Ideal for architecting enterprise-grade logging systems.

A comprehensive skill designed for senior Go security engineers. It guides users through robust security practices, including threat modeling (STRIDE), data flow tracing, and vulnerability analysis for Golang code. It provides specific modes for reviewing PRs, auditing full codebases, and writing secure code.

A comprehensive guide to the Go programming language ecosystem. This resource curates official documentation, essential newsletters, key developer profiles, and community hubs. Use this guide when you need to stay current with Go language features, discover new libraries, or keep up with industry best practices and community discussions.

A comprehensive guide to stretchr/testify for Go development. It covers best practices for writing readable unit tests, including the crucial distinction between `assert` and `require`. Learn advanced assertions (like `JSONEq` and `Eventually`), how to use `testify/mock` to isolate components, and structuring complex tests using `testify/suite`. Essential for professional Go projects.

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.

This skill guides the implementation of robust GraphQL APIs using Golang. It covers best practices for schema design (SDL), writing efficient resolvers, and critically, preventing N+1 database query issues using DataLoaders. Essential for building scalable, production-ready backend services.

This skill provides deep knowledge and usage patterns for `go.uber.org/dig`, a reflection-based dependency injection container for Go. It covers core concepts like `Provide` and `Invoke`, parameter grouping (`dig.In`), result handling (`dig.Out`), named values, and value groups. Ideal for architects wiring complex application graphs, building CLI tools, or creating libraries that require explicit dependency management at startup.

A robust application framework for Go, built on dig, designed for managing complex, long-running services. It provides advanced features including dependency injection (DI), structured lifecycle hooks (OnStart/OnStop), a modular system, and signal-aware run loops. It ensures services can manage graceful shutdowns and maintain architectural integrity.

This skill implements dependency injection for Go applications using the google/wire library. It resolves the entire dependency graph at compile time, generating plain Go constructor calls without requiring a runtime container or reflection. This approach enhances performance and enables early detection of dependency errors during the build phase, making it ideal for building robust, scalable Go services and microservices.