yzfly

Activate a Cognitive Digital Twin. Can simulate a custom subject (via core/ directory) OR load pre-installed celebrity/expert personas (from personas/ directory).

This skill covers Golang OpenAPI/Swagger documentation using swaggo/swag, including annotation comments, code generation, framework integrations (gin, echo, fiber, chi, net/http), security definitions, and struct tags. Apply it for adding or maintaining Swagger/OpenAPI docs in Go projects.

Golang code style, formatting, and conventions. Use when writing Go code, reviewing style, configuring linters, writing comments, or establishing project standards.

Golang CLI application development. Use when building, modifying, or reviewing a Go CLI tool, especially for command structure, flag handling, configuration layering, version embedding, exit codes, I/O patterns, signal handling, shell completion, argument validation, and CLI unit testing. Also triggers when code uses cobra, viper, or urfave/cli.

A comprehensive guide to dependency injection (DI) in Golang, covering its importance, manual constructor injection, and a comparison of popular DI libraries. Use this skill for designing service architecture, setting up DI, or refactoring code.

Learn idiomatic context.Context usage in Golang, covering creation, propagation, cancellation, timeouts, deadlines, context values, and cross-service tracing. Apply these principles when working with context.Context in any Go code.

Learn idiomatic Golang design patterns including functional options, constructors, error handling, resource management, graceful shutdown, and resilience. Apply these patterns when choosing architectural approaches, designing APIs, and managing application lifecycle.

Monadic types for Golang using samber/mo, including Option, Result, and other types, enable type-safe nullable values, robust error handling, and functional composition. Use this skill when working with `github.com/samber/mo` or exploring functional programming patterns for safer Golang designs.

This skill covers idiomatic Golang error handling, from creation and wrapping to custom types, panic/recover, and structured logging with slog and samber/oops, designed for scalable log aggregation and production error management.

This skill covers the uber-go/fx Golang application framework, detailing its core components like fx.New, fx.Provide, and fx.Invoke, along with lifecycle management. It's relevant for projects using or adopting uber-go/fx for dependency injection and service wiring.

Vercel Engineering's guidelines for React and Next.js performance optimization. Apply this skill when writing, reviewing, or refactoring React/Next.js code to ensure optimal performance patterns, especially for tasks involving components, pages, data fetching, bundle optimization, or performance improvements.

Implements GraphQL APIs in Golang with gqlgen or graphql-go. Apply this skill for building GraphQL servers, designing schemas, writing resolvers, handling subscriptions, or integrating GraphQL with existing Go HTTP services, particularly when github.com/99designs/gqlgen or github.com/graph-gophers/graphql-go are imported.

Recommends production-ready Golang libraries and frameworks. Apply when the user explicitly asks for library suggestions, wants to compare alternatives, needs to choose a library for a specific task, or when a new dependency is being added to the project.

samber/ro provides a ReactiveX implementation for Golang, enabling reactive streams and event-driven programming. It features over 150 type-safe operators, cold/hot observables, 5 subject types, declarative pipelines, 40+ plugins, automatic backpressure, error propagation, and Go context integration.

A Golang configuration library using spf13/viper, featuring layered precedence, environment variable handling, file reading, unmarshaling, sub-tree support, hot reload, test isolation, and remote KV integration.

Comprehensive documentation guide for Golang projects, covering godoc comments, README, CONTRIBUTING, CHANGELOG, Go Playground, Example tests, API docs, and llms.txt, to be used when writing or reviewing doc comments, documentation, adding code examples, setting up doc sites, or discussing documentation best practices. This guide triggers for both libraries and applications/CLIs.

Functional programming helpers for Golang using samber/lo, providing over 500 type-safe generic functions for slices, maps, channels, strings, math, tuples, and concurrency. It features core immutable, concurrent, in-place mutable, and lazy iterator packages.

Provides resources to stay updated with Golang news, communities and people to follow. Use when seeking Go learning resources, discovering new libraries, finding community channels, or keeping up with Go language changes and releases.

This skill covers Golang data structures such as slices, maps, arrays, container/list/heap/ring, strings.Builder vs bytes.Buffer, generic collections, pointers, and copy semantics. It's useful for choosing, optimizing, and implementing Go data structures and generic containers.

A Startup/AI-startup CTO who is also a top-tier individual contributor. Operates in two modes: (1) greenfield, turning fuzzy business intent into buildable designs through conversation; (2) brownfield, working hands-on within existing codebases to investigate, refactor, develop, and debug. Triggers when the user wants to build something.

This skill provides security best practices and vulnerability prevention for Golang, covering injection, cryptography, filesystem safety, network security, cookies, secrets management, memory safety, and logging. Apply it when writing, reviewing, or auditing Go code for security, especially for risky operations involving crypto, I/O, secrets, user input, or authentication.

A comprehensive guide to stretchr/testify for Golang testing, covering assert, require, mock, and suite packages in depth. Essential for testify assertions, mock expectations, argument matchers, and advanced patterns.

Provides best practices and configuration for golangci-lint in Go projects, covering linter execution, configuration, warning suppression, and output interpretation. Use this skill for tasks related to golangci-lint setup, usage, and managing code quality.

A comprehensive guide for Go database access, covering parameterized queries, transactions, connection pooling, and more. Use this skill when writing, reviewing, or debugging Golang code interacting with PostgreSQL, MariaDB, MySQL, or SQLite.

Structured error handling in Golang with samber/oops, featuring error builders, stack traces, error codes, context, wrapping, attributes, user/developer messages, panic recovery, and logger integration. Apply when using or adopting samber/oops, or when the codebase already imports it.

Explore Golang struct and interface design patterns, covering composition, embedding, type assertions, and dependency injection. Use this skill when designing Go types, implementing interfaces, or adding struct field tags for JSON/YAML.

This skill focuses on everyday Golang observability, covering always-on production signals like structured logging, Prometheus metrics, OpenTelemetry tracing, continuous profiling, RUM event tracking, alerting, and Grafana dashboards for Go services.

This comprehensive guide covers writing production-ready Golang tests, including table-driven tests, test suites, mocks, unit and integration tests, benchmarks, code coverage, parallel tests, fuzzing, and CI with GitHub Actions.

Systematically troubleshoot Golang programs to find and fix root causes of bugs, crashes, deadlocks, or unexpected behavior. It covers debugging methodology, common pitfalls, test-driven debugging, pprof, Delve, race detection, GODEBUG tracing, and production debugging.

Defensive Golang coding to prevent panics, silent data corruption, and subtle runtime bugs. Apply when writing or reviewing Go code involving nil-prone types, numeric conversions, resource lifecycle, or defensive copying, and for questions on nil panics, append aliasing, map concurrent access, or float comparison.

This skill covers Go (Golang) naming conventions for packages, structs, interfaces, constants, errors, and more. Use it when writing, reviewing, or refactoring Go code, especially when choosing between naming alternatives.

Golang benchmarking, profiling, and performance measurement. Use for writing, running, and comparing Go benchmarks, profiling hot paths with pprof, analyzing CPU/memory profiles, and investigating production performance with Prometheus metrics.

This skill focuses on in-memory caching in Golang with samber/hot, covering eviction algorithms (LRU, LFU, etc.), TTL, cache loaders, sharding, stale-while-revalidate, missing key caching, and Prometheus metrics. It applies when using samber/hot or when repeatedly loading medium-to-low cardinality resources.

Provides gRPC usage guidelines, protobuf organization, and production-ready patterns for Golang microservices. Use when implementing, reviewing, or debugging gRPC servers/clients, writing proto files, setting up interceptors, handling gRPC errors with status codes, configuring TLS/mTLS, testing with bufconn, or working with streaming RPCs.

Implements dependency injection in Golang using samber/do. Use this skill for dependency injection, service container setup, lifecycle management, refactoring, health checks, graceful shutdown, or organizing services into scopes/modules, especially with github.com/samber/do/v2.

This skill covers the spf13/cobra library for building Golang CLI command trees, including command execution, argument validation, flag management, command groups, shell completion, documentation generation, and testing.

This skill covers Golang concurrency patterns, useful for writing or reviewing concurrent Go code involving goroutines, channels, select, locks, sync primitives, errgroup, singleflight, worker pools, or fan-out/fan-in pipelines. It also triggers for goroutine leaks, race conditions, channel ownership issues, or when choosing between channels and mutexes.

Provides dependency management strategies for Golang projects, covering go.mod, package installation/upgrades, semantic versioning, vulnerability scanning, and automated updates. Use this skill for adding, removing, or updating dependencies.

Compile-time dependency injection in Golang with google/wire, covering features like wire.NewSet, wire.Build, wire.Bind, cleanup functions, and generated wire_gen.go. Apply when using or adopting google/wire or wiring an application graph.

Golang performance optimization patterns and methodology, covering allocation reduction, CPU efficiency, memory layout, GC tuning, pooling, caching, and hot-path optimization. Apply these patterns when profiling or benchmarks identify a bottleneck, or during performance code reviews to suggest improvements.

Structured logging extensions for Golang using samber/slog-**** packages, providing multi-handler pipelines, log sampling, attribute formatting, HTTP middleware, and backend routing. Apply these extensions when using or adopting slog in your codebase.

Provides a guide for setting up Golang project layouts and workspaces. Apply it for any Go project initialization, restructuring, or when organizing existing codebases, monorepos, and CLI tools.

Configures CI/CD pipelines for Golang projects using GitHub Actions, covering testing, security scanning, code coverage, and release automation. It's ideal for setting up CI, configuring workflows, and automating releases.

Implements dependency injection in Golang using uber-go/dig, a reflection-based container supporting Provide/Invoke, dig.In/dig.Out, named values, value groups, optional dependencies, scopes, and Decorate. Apply this when using or adopting uber-go/dig, or when wiring an application graph at startup.

Continuously modernize Go code to leverage the latest language features, standard library improvements, and idiomatic patterns. Use this skill for writing, reviewing, or refactoring Go code, and when addressing Go upgrades, migration, modernization, deprecation, or linter issues, including tooling modernization.