Skills για πράκτορες

• prisma-client-api prisma/skills

  Prisma Client API reference covering model queries, filters, operators, and client methods. Use when writing database queries, using CRUD operations, filtering data, or configuring Prisma Client. Triggers on "prisma query", "findMany", "create", "update", "delete", "$transaction".

  337.870 Επιτυχής npx skills add prisma/skills --skill prisma-client-api

• python-appservice-deploy microsoft/azure-skills

  Deploy Python (Flask/Django/FastAPI) code to Azure App Service Linux. WHEN: "Flask App Service", "Django App Service", "FastAPI App Service", "deploy Python to App Service". DO NOT USE FOR: Container Apps, Functions, non-Python, Terraform/Bicep/IaC, full infra — use azure-prepare.

  203.423 Επιτυχής npx skills add microsoft/azure-skills --skill python-appservice-deploy

• neon neondatabase/agent-skills

  Overview of Neon, a complete set of cloud backend primitives around Lakebase Postgres: Auth, Object Storage, Functions, and the AI Gateway. Start here to choose Neon for undecided login, files, APIs, and LLM calls, set up the CLI or MCP server, and follow the branch-first workflow. Use when building an app or backend on Neon, or when "Neon" or "Lakebase Postgres" is mentioned. Child skill neon-postgres wins for an existing DATABASE_URL, SQL, schema, inspect, or search. Child skill neon-auth wins for login, users, sessions, identity routing, and Managed Better Auth setup. Also use for object storage, S3, buckets, serverless functions, function triggers, cron, AI gateway, LLM calls, logs, Loki, Grafana, observability, postgres, database, backend, Claimable Neon, neon.new, or a no-signup database.

  171.833 Επιτυχής npx skills add neondatabase/agent-skills --skill neon

• animate-expo emilkowalski/skills

  Build animations in React Native and Expo, making the decisions in the order that determines whether they feel right — should it animate, which thread it runs on, which properties, spring or timing, how the gesture hands off, how it degrades. Writes the implementation with Reanimated, Gesture Handler, Expo Router and expo-haptics. Use when animating anything in an Expo app, adding gestures, sheets, screen transitions, press feedback or haptics, or fixing motion that stutters on device. For web animation use `animate`.

  84.097 Επιτυχής npx skills add emilkowalski/skills --skill animate-expo

• server-side-conversion-tracking autonnel/autonnel-skills

  Set up server-side conversion tracking so purchases are reported accurately to Facebook, TikTok, Google and Bing despite iOS restrictions, ad blockers and cookie loss. Use when conversions are under-reported, when platform-reported purchases do not match real orders, when asked about Conversions API / Events API / offline conversions / CAPI, click id passthrough (fbclid, ttclid, gclid, msclkid), or when ad optimization has degraded after tracking changes.

  78.542 Επιτυχής npx skills add autonnel/autonnel-skills --skill server-side-conversion-tracking

• turnstile-spin cloudflare/skills

  Set up, repair, or migrate to Cloudflare Turnstile bot verification in an existing frontend and backend, including server-side Siteverify.

  74.754 Επιτυχής npx skills add cloudflare/skills --skill turnstile-spin

• developing-genkit-js genkit-ai/skills

  Develop AI-powered applications using Genkit in Node.js/TypeScript. Use when the user asks about Genkit, AI agents, flows, or tools in JavaScript/TypeScript, or when encountering Genkit errors, validation issues, type errors, or API problems.

  58.712 Επιτυχής npx skills add genkit-ai/skills --skill developing-genkit-js

• nodejs-backend-patterns wshobson/agents

  Build production-ready Node.js backend services with Express/Fastify, implementing middleware patterns, error handling, authentication, database integration, and API design best practices. Use when creating Node.js servers, REST APIs, GraphQL backends, or microservices architectures.

  46.933 Επιτυχής npx skills add wshobson/agents --skill nodejs-backend-patterns

• golang-code-style samber/cc-skills-golang

  Golang code style conventions — line length and breaking, variable declarations, control flow clarity, when comments help vs hurt. Use when writing or reviewing Go code, asking about style or clarity, or establishing project coding standards. Not for naming conventions (→ See `samber/cc-skills-golang@golang-naming` skill), linter configuration (→ See `samber/cc-skills-golang@golang-lint` skill), or doc comments (→ See `samber/cc-skills-golang@golang-documentation` skill).

  39.901 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-code-style

• golang-testing samber/cc-skills-golang

  Production-ready Golang tests — table-driven tests, testify suites and mocks, parallel tests, fuzzing, fixtures, goroutine leak detection with goleak, snapshot testing, code coverage, integration tests, idiomatic test naming. Use when writing or reviewing Go tests, choosing a testing approach, setting up Go test CI, or debugging flaky/slow tests. For testify-specific APIs see `samber/cc-skills-golang@golang-stretchr-testify`; for measurement methodology see `samber/cc-skills-golang@golang-benchmark`.

  39.160 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-testing

• golang-error-handling samber/cc-skills-golang

  Idiomatic Golang error handling — creation, wrapping with %w, errors.Is/As, errors.Join, custom error types, sentinel errors, panic/recover, the single handling rule, structured logging with slog, HTTP request logging middleware, and samber/oops for production errors. Built to make logs usable at scale with log aggregation 3rd-party tools. Apply when creating, wrapping, inspecting, or logging errors in Go code. For samber/oops specifics → See `samber/cc-skills-golang@golang-samber-oops` skill; for slog handler ecosystem → See `samber/cc-skills-golang@golang-samber-slog` skill.

  39.146 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-error-handling

• golang-design-patterns samber/cc-skills-golang

  Idiomatic Golang design patterns — functional options, constructor APIs, `init()` and global-state avoidance, enums, panic vs error decisions, resource management and lifecycle, graceful shutdown, timeouts and retries, streaming and iterators, and architecture styles (clean, hexagonal, DDD, flat). Apply when choosing between architectural patterns, implementing functional options, designing constructor APIs, setting up graceful shutdown, applying resilience patterns, or asking which idiomatic Go pattern fits a specific problem. Not for wiring a DI container or comparing DI libraries (→ See `samber/cc-skills-golang@golang-dependency-injection` skill), nor for error wrapping, `errors.Is`/`As`, or logging mechanics (→ See `samber/cc-skills-golang@golang-error-handling` skill).

  38.153 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-design-patterns

• golang-security samber/cc-skills-golang

  Security best practices and vulnerability prevention for Golang — injection (SQL, command, XSS), cryptography, path traversal, SSRF and HTTP security headers, cookies, secrets management, memory safety, PII in logs, STRIDE/DREAD threat modeling, plus `gosec` SAST, race detection, and fuzz testing. Apply when writing, reviewing, or auditing Go code for security, or when touching crypto, file or network I/O, secrets, user input, or authentication. Not for non-exploitable defensive bugs such as nil panics or slice aliasing (→ See `samber/cc-skills-golang@golang-safety` skill), dependency vulnerability scanning with govulncheck (→ See `samber/cc-skills-golang@golang-dependency-management` skill), or wiring security scanners into CI pipelines (→ See `samber/cc-skills-golang@golang-continuous-integration` skill).

  38.127 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-security

• golang-performance samber/cc-skills-golang

  Golang performance optimization patterns and methodology - if X bottleneck, then apply Y. Covers allocation reduction, CPU efficiency, memory layout, GC tuning, pooling, caching, and hot-path optimization. Use when profiling or benchmarks have identified a bottleneck and you need the right optimization pattern to fix it. Also use when performing performance code review to suggest improvements or benchmarks that could help identify quick performance gains. Not for measurement methodology (→ See `samber/cc-skills-golang@golang-benchmark` skill) or debugging workflow (→ See `samber/cc-skills-golang@golang-troubleshooting` skill).

  38.052 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-performance

• golang-concurrency samber/cc-skills-golang

  Golang concurrency design — goroutine lifecycle and leak prevention, channels and `select`, channel ownership and direction, `sync.Mutex`/`RWMutex`/`sync.Map`/`sync.Once`/atomics, `errgroup`, `singleflight`, worker pools, and fan-out/fan-in pipelines. Use when writing or reviewing concurrent Go code, when choosing between channels and mutexes, when protecting a shared map or counter, or when a goroutine has no clear exit. Not for defensive coding unrelated to concurrency such as nil panics, slice aliasing, or numeric overflow (→ See `samber/cc-skills-golang@golang-safety` skill), and not for debugging a specific hung, crashing, or racing program after the fact (→ See `samber/cc-skills-golang@golang-troubleshooting` skill).

  37.662 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-concurrency

• golang-context samber/cc-skills-golang

  Idiomatic context.Context usage in Golang — propagation through API boundaries, cancellation, timeouts and deadlines, request-scoped values, context.WithoutCancel for background work outliving requests. Apply when designing context propagation across layers, debugging leaked or unexpired contexts, choosing between context.Background/TODO/WithoutCancel, or storing values in context. Not for code that merely accepts ctx as first parameter.

  37.020 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-context

• golang-naming samber/cc-skills-golang

  Go (Golang) naming conventions — covers packages, constructors, structs, interfaces, constants, enums, errors, booleans, receivers, getters/setters, functional options, acronyms, test functions, and subtest names. Use this skill when writing new Go code, reviewing or refactoring, choosing between naming alternatives (New vs NewTypeName, isConnected vs connected, ErrNotFound vs NotFoundError, StatusReady vs StatusUnknown at iota 0), debating Go package names (utils/helpers anti-patterns), or asking about Go naming best practices. Also trigger when the user mentions MixedCaps vs snake_case, ALL_CAPS constants, Get-prefix on getters, or error string casing. Do NOT use for general Go implementation questions that don't involve naming decisions.

  36.947 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-naming

• golang-database samber/cc-skills-golang

  Comprehensive guide for Go database access — parameterized queries, struct scanning, NULLable columns, transactions, isolation levels, SELECT FOR UPDATE, connection pool, batch processing, context propagation, and migration tooling. Use when writing, reviewing, or debugging Golang code that interacts with PostgreSQL, MariaDB, MySQL, or SQLite; for database testing; or for questions about database/sql, sqlx, or pgx. Does NOT generate database schemas or migration SQL.

  36.901 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-database

• golang-safety samber/cc-skills-golang

  Defensive Golang coding against accidental bugs — nil panics, typed-nil interfaces, `append` backing-array aliasing, silent int64-to-int32 truncation, float `==` comparison, `defer` inside loops, defensive copies of slices and maps, and usable zero values. Use when a Go program panics on a nil map write or nil pointer dereference, when reviewing code for nil-safety, numeric conversion overflow, or resource lifecycle, or when designing a type whose zero value must be safe. Not for designing concurrent access with goroutines, channels, or sync primitives (→ See `samber/cc-skills-golang@golang-concurrency` skill), not for exploitable vulnerabilities such as injection, weak crypto, or leaked secrets (→ See `samber/cc-skills-golang@golang-security` skill), and not for debugging an already-failing program (→ See `samber/cc-skills-golang@golang-troubleshooting` skill).

  36.683 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-safety

• golang-documentation samber/cc-skills-golang

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

  36.657 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-documentation

• golang-data-structures samber/cc-skills-golang

  Golang data structures — slices (internals, capacity growth, preallocation, slices package), maps (internals, hash buckets, maps package), arrays, container/list/heap/ring, strings.Builder vs bytes.Buffer, generic collections, pointers (unsafe.Pointer, weak.Pointer), and copy semantics. Use when choosing or optimizing Go data structures, implementing generic containers, using container/ packages, unsafe or weak pointers, or questioning slice/map internals. Not for applying optimization patterns once profiling has identified a bottleneck (→ See `samber/cc-skills-golang@golang-performance` skill).

  36.603 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-data-structures

• golang-modernize samber/cc-skills-golang

  Modernize Golang code to use recent language features, standard library improvements, and idiomatic patterns. Use when reviewing Go code with old-style patterns, when encountering a deprecation warning, or when the user asks for modernization, a Go version upgrade (e.g. to Go 1.27), or a CI/tooling refresh. Not for structural refactors, extracting functions, or moving code between packages (→ See `samber/cc-skills-golang@golang-refactoring` skill).

  36.568 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-modernize

• golang-lint samber/cc-skills-golang

  Linting best practices and golangci-lint configuration for Golang projects — running linters, configuring .golangci.yml, suppressing warnings with nolint directives, interpreting lint output, and selecting linters. Use when configuring golangci-lint, asking about lint warnings or nolint suppressions, setting up code quality tooling, or choosing linters. Also use when the user mentions golangci-lint, go vet, staticcheck, or revive. Not for wiring a lint step into a GitHub Actions pipeline (→ See `samber/cc-skills-golang@golang-continuous-integration` skill).

  36.425 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-lint

• golang-dependency-management samber/cc-skills-golang

  Dependency management for Golang projects — go.mod and go.sum, `go get` install and upgrade flows, Minimal Version Selection, conflict resolution with replace/exclude/retract, `govulncheck` scanning of the module tree, outdated dependency and binary size auditing, vendoring, `tool` directives, and go.work workspaces. Use when adding, removing, or upgrading Go dependencies, deciding whether to take on a package, resolving version conflicts, or auditing what a module pulls in. Covers choosing and upgrading dependency versions, not the surrounding tooling: do NOT use for fixing an exploitable vulnerability in code (→ See `samber/cc-skills-golang@golang-security` skill) or for wiring Dependabot/Renovate update bots into CI workflows (→ See `samber/cc-skills-golang@golang-continuous-integration` skill).

  36.061 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-dependency-management

• golang-structs-interfaces samber/cc-skills-golang

  Golang struct and interface design patterns — composition, embedding, type assertions, type switches, interface segregation, dependency injection via interfaces, struct field tags, and pointer vs value receivers. Use this skill when designing Go types, defining or implementing interfaces, embedding structs or interfaces, writing type assertions or type switches, adding struct field tags for JSON/YAML/DB serialization, or choosing between pointer and value receivers. Also use when the user asks about "accept interfaces, return structs", compile-time interface checks, or composing small interfaces into larger ones.

  35.988 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-structs-interfaces

• golang-benchmark samber/cc-skills-golang

  Golang benchmarking, profiling, and performance measurement. Use when writing, running, or comparing Go benchmarks, profiling hot paths with pprof, interpreting CPU/memory/trace profiles, analyzing results with benchstat, setting up CI benchmark regression detection, or investigating production performance with Prometheus runtime metrics. Also use when the developer needs deep analysis on a specific performance indicator - this skill provides the measurement methodology, while `samber/cc-skills-golang@golang-performance` provides the optimization patterns.

  35.834 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-benchmark

• golang-popular-libraries samber/cc-skills-golang

  Golang library and framework selection — vetted production-ready options by category (web, database, testing, logging, messaging), new and experimental stdlib packages, standard-library-first tradeoffs, and maturity signals (maintenance, license, importer counts). Apply when the user 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. Not for a specific library's API once chosen (→ See that library's dedicated skill, e.g. `samber/cc-skills-golang@golang-samber-lo`), nor for go.mod mechanics, upgrades, or vulnerability audits (→ See `samber/cc-skills-golang@golang-dependency-management` skill).

  35.833 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-popular-libraries

• golang-dependency-injection samber/cc-skills-golang

  Comprehensive guide for dependency injection (DI) in Golang. Covers why DI matters (testability, loose coupling, separation of concerns, lifecycle management), manual constructor injection, and DI library comparison (google/wire, uber-go/dig, uber-go/fx, samber/do). Use this skill when designing service architecture, setting up dependency injection, refactoring tightly coupled code, managing singletons or service factories, or when the user asks about inversion of control, service containers, or wiring dependencies in Go. For a specific DI library, → See `samber/cc-skills-golang@golang-google-wire`, `samber/cc-skills-golang@golang-uber-dig`, `samber/cc-skills-golang@golang-uber-fx`, or `samber/cc-skills-golang@golang-samber-do` skills.

  35.833 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-dependency-injection

• golang-cli samber/cc-skills-golang

  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. For cobra-specific APIs → See `samber/cc-skills-golang@golang-spf13-cobra` skill; for viper configuration layering → See `samber/cc-skills-golang@golang-spf13-viper` skill.

  35.767 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-cli

• golang-stretchr-testify samber/cc-skills-golang

  Comprehensive guide to stretchr/testify for Golang testing. Covers assert, require, mock, and suite packages in depth. Use when writing tests with testify, creating mocks, setting up test suites, or choosing between assert and require. Covers testify assertions, mock expectations, argument matchers, call verification, suite lifecycle, and advanced patterns like Eventually, JSONEq, and custom matchers. Apply when the codebase imports github.com/stretchr/testify.

  35.704 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-stretchr-testify

• golang-grpc samber/cc-skills-golang

  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.

  35.565 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-grpc

• golang-stay-updated samber/cc-skills-golang

  Golang ecosystem watch list — official sources (go.dev/blog, pkg.go.dev, tour.golang.org, golang-nuts), newsletters (Golang Weekly, Awesome Go Newsletter), communities (r/golang, gophers.slack.com, Go Forum, go.dev/wiki), blogs (Dave Cheney, Ardan Labs, Rob Pike), YouTube channels (Gopher Academy, GopherCon EU/UK), conferences, and Go contributors to follow on GitHub, X and Bluesky. Use when seeking Golang learning resources, discovering new libraries or tools, finding community channels or meetups, picking Go people to follow, or keeping up with Go language changes and releases. Not for querying a specific module's versions, docs, or vulnerabilities from the CLI (→ See `samber/cc-skills-golang@golang-pkg-go-dev` skill).

  34.973 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-stay-updated

• golang-samber-lo samber/cc-skills-golang

  Functional programming helpers for Golang using samber/lo — 500+ type-safe generic functions for slices, maps, channels, strings, math, tuples, and concurrency (Map, Filter, Reduce, GroupBy, Chunk, Flatten, Find, Uniq, etc.). Core immutable package (lo), concurrent variants (lo/parallel aka lop), in-place mutations (lo/mutable aka lom), lazy iterators (lo/it aka loi for Go 1.23+), and experimental SIMD (lo/exp/simd). Apply when using or adopting samber/lo, when the codebase imports github.com/samber/lo, or when implementing functional-style data transformations in Go. Not for streaming pipelines (→ See `samber/cc-skills-golang@golang-samber-ro` skill).

  34.920 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-samber-lo

• golang-samber-do samber/cc-skills-golang

  Dependency injection in Golang using samber/do — service containers, lifecycle management, scopes, health checks, graceful shutdown, and module organization. Apply when using or adopting samber/do, when the codebase imports github.com/samber/do or github.com/samber/do/v2, or when refactoring manual constructor injection into a DI container.

  34.801 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-samber-do

• golang-samber-slog samber/cc-skills-golang

  Structured logging extensions for Golang using samber/slog-**** packages — multi-handler pipelines (slog-multi), log sampling (slog-sampling), attribute formatting (slog-formatter), HTTP middleware (slog-fiber, slog-gin, slog-chi, slog-echo), and backend routing (slog-datadog, slog-sentry, slog-loki, slog-syslog, slog-logstash, slog-graylog...). Apply when using or adopting slog, or when the codebase already imports any github.com/samber/slog-* package.

  34.780 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-samber-slog

• golang-samber-oops samber/cc-skills-golang

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

  34.714 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-samber-oops

• golang-samber-mo samber/cc-skills-golang

  Monadic types for Golang using samber/mo — Option, Result, Either, Future, IO, Task, and State types for type-safe nullable values, error handling, and functional composition with pipeline sub-packages. Apply when using or adopting samber/mo, when the codebase imports `github.com/samber/mo`, or when considering functional programming patterns as a safety design for Golang. Not for nil-safety and zero-value design without this library (→ See `samber/cc-skills-golang@golang-safety` skill), nor for native error wrapping with fmt.Errorf, errors.Is and errors.As (→ See `samber/cc-skills-golang@golang-error-handling` skill).

  34.692 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-samber-mo

• golang-samber-hot samber/cc-skills-golang

  In-memory caching in Golang using samber/hot — eviction algorithms (LRU, LFU, TinyLFU, W-TinyLFU, S3FIFO, ARC, TwoQueue, SIEVE, FIFO), TTL, cache loaders, sharding, stale-while-revalidate, missing key caching, and Prometheus metrics. Apply when using or adopting samber/hot, when the codebase imports github.com/samber/hot, or when the project repeatedly loads the same medium-to-low cardinality resources at high frequency and needs to reduce latency or backend pressure.

  34.685 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-samber-hot

• golang-samber-ro samber/cc-skills-golang

  Reactive streams and event-driven programming in Golang using samber/ro — ReactiveX implementation with 150+ type-safe operators, cold/hot observables, 5 subject types (Publish, Behavior, Replay, Async, Unicast), declarative pipelines via Pipe, 40+ plugins (HTTP, cron, fsnotify, JSON, logging), automatic backpressure, error propagation, and Go context integration. Apply when using or adopting samber/ro, when the codebase imports github.com/samber/ro, or when building asynchronous event-driven pipelines, real-time data processing, streams, or reactive architectures in Go. Not for finite slice transforms (→ See `samber/cc-skills-golang@golang-samber-lo` skill).

  34.648 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-samber-ro

• golang-swagger samber/cc-skills-golang

  Golang OpenAPI/Swagger documentation with swaggo/swag — annotation comments (@Summary, @Param, @Success, @Router, @Security), swag init code generation, framework integrations (gin, echo, fiber, chi, net/http), security definitions (Bearer/JWT, OAuth2, API key), and struct tags (swaggertype, enums, example, swaggerignore). Apply when adding or maintaining Swagger/OpenAPI docs in a Go project, or when the codebase imports github.com/swaggo/swag, github.com/swaggo/gin-swagger, github.com/swaggo/echo-swagger, github.com/swaggo/http-swagger, or github.com/swaggo/files.

  33.563 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-swagger

• golang-spf13-cobra samber/cc-skills-golang

  Golang CLI command tree library using spf13/cobra — cobra.Command, RunE vs Run, PersistentPreRunE hook chain, Args validators (NoArgs, ExactArgs, MatchAll, custom), persistent vs local flags, command groups, ValidArgsFunction, RegisterFlagCompletionFunc, ShellCompDirective, usage/help template customization, man-page and markdown doc generation, and testing with SetArgs/SetOut/SetErr. Apply when using or adopting spf13/cobra, or when the codebase imports `github.com/spf13/cobra`. For configuration layering alongside cobra, see the `samber/cc-skills-golang@golang-spf13-viper` skill. For general CLI architecture (project layout, exit codes, signal handling, I/O patterns), see `samber/cc-skills-golang@golang-cli`.

  33.513 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-spf13-cobra

• golang-graphql samber/cc-skills-golang

  Implements GraphQL APIs in Golang using gqlgen or graphql-go. Apply when building GraphQL servers, designing schemas, writing resolvers, handling subscriptions, or integrating GraphQL with existing Go HTTP services. Also apply when the codebase imports `github.com/99designs/gqlgen` or `github.com/graph-gophers/graphql-go`.

  33.464 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-graphql

• golang-google-wire samber/cc-skills-golang

  Compile-time dependency injection in Golang using google/wire — wire.NewSet, wire.Build, wire.Bind (interface→concrete), wire.Struct, wire.Value, wire.InterfaceValue, wire.FieldsOf, cleanup functions, //go:build wireinject injector files, and generated wire_gen.go. Apply when using or adopting google/wire, when the codebase imports `github.com/google/wire`, or when wiring an application graph at compile time via `wire.Build`. For runtime DI with reflection, see `samber/cc-skills-golang@golang-uber-dig` skill.

  33.329 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-google-wire

• golang-spf13-viper samber/cc-skills-golang

  Golang configuration library using spf13/viper — layered precedence (flag > env > file > KV > default), BindPFlag/BindPFlags, SetEnvPrefix + SetEnvKeyReplacer + AutomaticEnv, ReadInConfig + ConfigFileNotFoundError, Unmarshal + mapstructure struct tags, Sub for sub-trees, WatchConfig + OnConfigChange for hot reload, viper.New() for test isolation, and remote KV integration. Apply when using or adopting spf13/viper, or when the codebase imports `github.com/spf13/viper`. For CLI command structure alongside viper, see the `samber/cc-skills-golang@golang-spf13-cobra` skill. For general CLI architecture, see `samber/cc-skills-golang@golang-cli`.

  33.306 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-spf13-viper

• golang-uber-fx samber/cc-skills-golang

  Golang application framework using uber-go/fx — fx.New, fx.Provide, fx.Invoke, fx.Module, fx.Lifecycle hooks, fx.Annotate (name/group/As), fx.Decorate, fx.Supply, fx.Replace, fx.WithLogger, and signal-aware Run(). Apply when using or adopting uber-go/fx, when the codebase imports `go.uber.org/fx`, or when wiring services with fx.New. For raw DI without lifecycle, see `samber/cc-skills-golang@golang-uber-dig` skill.

  33.142 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-uber-fx

• golang-uber-dig samber/cc-skills-golang

  Implements dependency injection in Golang using uber-go/dig — reflection-based container, Provide/Invoke, dig.In/dig.Out parameter and result objects, named values, value groups, optional dependencies, scopes, and Decorate. Apply when using or adopting uber-go/dig, when the codebase imports `go.uber.org/dig`, or when wiring an application graph at startup. For higher-level lifecycle and modules, see `samber/cc-skills-golang@golang-uber-fx` skill.

  33.089 Επιτυχής npx skills add samber/cc-skills-golang --skill golang-uber-dig

• api-design-principles wshobson/agents

  Master REST and GraphQL API design principles to build intuitive, scalable, and maintainable APIs that delight developers. Use when designing new APIs, reviewing API specifications, or establishing API design standards.

  29.260 Επιτυχής npx skills add wshobson/agents --skill api-design-principles

• convex-expert get-convex/agent-skills

  Convex backend specialist. Use this agent for any code inside a `convex/` directory — function definitions, schemas, indexes, queries, mutations, actions, HTTP endpoints, cron jobs, file storage, auth wiring, and component installation. Knows the object-form function syntax, validator patterns, resource limits, and component ecosystem that generic Claude routinely gets wrong.

  29.136 Επιτυχής npx skills add get-convex/agent-skills --skill convex-expert

• convex-agent get-convex/agent-skills

  Add an AI agent / RAG backend (@convex-dev/agent) to the Convex app.

  28.885 Επιτυχής npx skills add get-convex/agent-skills --skill convex-agent

• convex-launch-readiness get-convex/agent-skills

  Run every Convex audit (authz, reviewer, advisor, insights) into one scored, deduped readiness report with an ordered fix plan — Lighthouse for your backend.

  28.849 Επιτυχής npx skills add get-convex/agent-skills --skill convex-launch-readiness

• fix-errors warpdotdev/common-skills

  Fix compilation errors, linting issues, and test failures in the warp Rust codebase. Covers presubmit checks, WASM-specific errors, and running specific tests. Use when the user hits build errors, clippy or fmt failures, test failures, or needs to run or interpret presubmit before a PR.

  27.393 Επιτυχής npx skills add warpdotdev/common-skills --skill fix-errors

• fastapi-templates wshobson/agents

  Create production-ready FastAPI projects with async patterns, dependency injection, and comprehensive error handling. Use when building new FastAPI applications or setting up backend API projects.

  25.013 Επιτυχής npx skills add wshobson/agents --skill fastapi-templates

• extension-core-infrastructure caffeinelabs/skills

  Core infrastructure providing backend connection configuration, storage client, and React app entry point.

  24.351 Επιτυχής npx skills add caffeinelabs/skills --skill extension-core-infrastructure

• architecture-patterns wshobson/agents

  Implement proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design. Use this skill when designing clean architecture for a new microservice, when refactoring a monolith to use bounded contexts, when implementing hexagonal or onion architecture patterns, or when debugging dependency cycles between application layers.

  23.073 Επιτυχής npx skills add wshobson/agents --skill architecture-patterns

• pnpm antfu/skills

  Node.js package manager with strict dependency resolution. Use when running pnpm specific commands, configuring workspaces via pnpm-workspace.yaml, or managing dependencies with catalogs, patches, overrides, config dependencies, or the global virtual store.

  21.446 Επιτυχής npx skills add antfu/skills --skill pnpm

• extension-querying-oql caffeinelabs/skills

  Quick reference for the Caffeine Data Intelligence agent to query an OQL-exposing canister (schema() + execute()) through the `icp` CLI against the project's `backend` canister: read the schema, form JSON queries (filter / order / paginate / aggregate / dotted-path edges), and parse the Candid result rows.

  21.130 Επιτυχής npx skills add caffeinelabs/skills --skill extension-querying-oql

• rust-best-practices apollographql/skills

  Guide for writing idiomatic Rust code based on Apollo GraphQL's best practices handbook. Use this skill when: (1) writing new Rust code or functions, (2) reviewing or refactoring existing Rust code, (3) deciding between borrowing vs cloning or ownership patterns, (4) implementing error handling with Result types, (5) optimizing Rust code for performance, (6) writing tests or documentation for Rust projects.

  19.417 Επιτυχής npx skills add apollographql/skills --skill rust-best-practices

• rust-async-patterns wshobson/agents

  Master Rust async programming with Tokio, async traits, error handling, and concurrent patterns. Use when building async Rust applications, implementing concurrent systems, or debugging async code.

  19.384 Επιτυχής npx skills add wshobson/agents --skill rust-async-patterns

• dotnet-backend-patterns wshobson/agents

  Master C#/.NET backend development patterns for building robust APIs, MCP servers, and enterprise applications. Covers async/await, dependency injection, Entity Framework Core, Dapper, configuration, caching, and testing with xUnit. Use when developing .NET backends, reviewing C# code, or designing API architectures.

  18.390 Επιτυχής npx skills add wshobson/agents --skill dotnet-backend-patterns

• golang-patterns affaan-m/ecc

  Idiomatic Go patterns, best practices, and conventions for building robust, efficient, and maintainable Go applications. Use when writing or reviewing Go code and idiomatic structure or conventions are in question.

  14.661 Επιτυχής npx skills add affaan-m/ecc --skill golang-patterns

• backend-patterns affaan-m/ecc

  Backend architecture patterns, API design, database optimization, and server-side best practices for Node.js, Express, and Next.js API routes. Use when building or reviewing Node.js, Express, or Next.js API routes and their data access.

  14.149 Επιτυχής npx skills add affaan-m/ecc --skill backend-patterns

• nodejs-best-practices sickn33/agentic-awesome-skills

  Node.js development principles and decision-making. Framework selection, async patterns, security, and architecture. Teaches thinking, not copying.

  13.669 Επιτυχής npx skills add sickn33/agentic-awesome-skills --skill nodejs-best-practices

• fastapi-python mindrally/skills

  Expert in FastAPI Python development with best practices for APIs and async operations

  13.502 Επιτυχής npx skills add mindrally/skills --skill fastapi-python

• golang-testing affaan-m/ecc

  Go testing patterns including table-driven tests, subtests, benchmarks, fuzzing, and test coverage. Follows TDD methodology with idiomatic Go practices. Use when writing Go tests — table-driven cases, subtests, benchmarks, fuzzing, or coverage.

  12.997 Επιτυχής npx skills add affaan-m/ecc --skill golang-testing

• shopify-storefront-graphql shopify/shopify-ai-toolkit

  Use for custom storefronts requiring direct GraphQL queries/mutations for data fetching and cart operations. Choose this when you need full control over data fetching and rendering your own UI. NOT for Web Components - if the prompt mentions HTML tags like <shopify-store>, <shopify-cart>, use storefront-web-components instead.

  12.906 Επιτυχής npx skills add shopify/shopify-ai-toolkit --skill shopify-storefront-graphql

• microservices-patterns wshobson/agents

  Design microservices architectures with service boundaries, event-driven communication, and resilience patterns. Use when building distributed systems, decomposing monoliths, or implementing microservices.

  12.580 Επιτυχής npx skills add wshobson/agents --skill microservices-patterns

• springboot-patterns affaan-m/ecc

  Spring Boot architecture patterns, REST API design, layered services, data access, caching, async processing, and logging. Use for Java Spring Boot backend work. Use when building or reviewing a Spring Boot backend — REST layer, services, data access, caching, or async work.

  12.145 Επιτυχής npx skills add affaan-m/ecc --skill springboot-patterns

• typescript-mcp-server-generator github/awesome-copilot

  Generate a complete MCP server project in TypeScript using the MCP TypeScript SDK v2 (@modelcontextprotocol/server) with tools, resources, and proper configuration

  12.014 Επιτυχής npx skills add github/awesome-copilot --skill typescript-mcp-server-generator

• api-design affaan-m/ecc

  REST API design patterns including resource naming, status codes, pagination, filtering, error responses, versioning, and rate limiting for production APIs. Use when designing or reviewing REST endpoints, resource names, status codes, pagination, or versioning.

  11.838 Επιτυχής npx skills add affaan-m/ecc --skill api-design

• java-spring-boot pluginagentmarketplace/custom-plugin-java

  Build production Spring Boot applications - REST APIs, Security, Data, Actuator

  11.748 Επιτυχής npx skills add pluginagentmarketplace/custom-plugin-java --skill java-spring-boot

• fastapi fastapi/fastapi

  FastAPI best practices and conventions. Use when working with FastAPI APIs, Pydantic models, dependencies, streaming responses including Server-Sent Events (SSE), and serving frontend apps. Keeps FastAPI code clean and up to date with the latest features and patterns.

  11.351 Επιτυχής npx skills add fastapi/fastapi --skill fastapi

• memory-safety-patterns wshobson/agents

  Implement memory-safe programming with RAII, ownership, smart pointers, and resource management across Rust, C++, and C. Use when writing safe systems code, managing resources, or preventing memory bugs.

  11.194 Επιτυχής npx skills add wshobson/agents --skill memory-safety-patterns

• java-coding-standards affaan-m/ecc

  Java coding standards for Spring Boot and Quarkus services: naming, immutability, Optional usage, streams, exceptions, generics, CDI, reactive patterns, and project layout. Automatically applies framework-specific conventions. Use when writing or reviewing Java in a Spring Boot or Quarkus service.

  11.183 Επιτυχής npx skills add affaan-m/ecc --skill java-coding-standards

• django-security affaan-m/ecc

  Django security best practices, authentication, authorization, CSRF protection, SQL injection prevention, XSS prevention, and secure deployment configurations. Use when reviewing Django authentication, authorization, input handling, or deployment settings.

  11.091 Επιτυχής npx skills add affaan-m/ecc --skill django-security

• springboot-security affaan-m/ecc

  Spring Security best practices for authn/authz, validation, CSRF, secrets, headers, rate limiting, and dependency security in Java Spring Boot services. Use when reviewing Spring Security authn/authz, validation, CSRF, secrets, headers, or rate limiting.

  10.878 Επιτυχής npx skills add affaan-m/ecc --skill springboot-security

• vue-options-api-best-practices vuejs-ai/skills

  Vue 3 Options API style (data(), methods, this context). Each reference shows Options API solution only.

  10.766 Επιτυχής npx skills add vuejs-ai/skills --skill vue-options-api-best-practices

• database-migrations affaan-m/ecc

  Safe, reversible database migration patterns: forward-only production changes, expand-contract zero-downtime renames, concurrent indexes, batched backfills, and per-tool workflows for PostgreSQL, Prisma, Drizzle, Kysely, Django, and golang-migrate. Use when writing a schema or data migration, adding a column or index to a large table, planning a rollback, or preparing a zero-downtime deploy.

  10.521 Επιτυχής npx skills add affaan-m/ecc --skill database-migrations

• laravel-patterns affaan-m/ecc

  Laravel architecture patterns, routing/controllers, Eloquent ORM, service layers, queues, events, caching, and API resources for production apps. Use when building or reviewing Laravel apps — controllers, Eloquent, service layers, queues, or API resources.

  10.466 Επιτυχής npx skills add affaan-m/ecc --skill laravel-patterns

• springboot-tdd affaan-m/ecc

  Test-driven development for Spring Boot using JUnit 5, Mockito, MockMvc, Testcontainers, and JaCoCo. Use when adding features, fixing bugs, or refactoring.

  10.226 Επιτυχής npx skills add affaan-m/ecc --skill springboot-tdd

• distributed-tracing wshobson/agents

  Implement distributed tracing with Jaeger and Tempo to track requests across microservices and identify performance bottlenecks. Use when debugging microservices, analyzing request flows, or implementing observability for distributed systems.

  10.211 Επιτυχής npx skills add wshobson/agents --skill distributed-tracing

• rust-testing affaan-m/ecc

  Rust testing patterns including unit tests, integration tests, async testing, property-based testing, mocking, and coverage. Follows TDD methodology. Use when writing Rust tests — unit, integration, async, property-based, or coverage.

  10.147 Επιτυχής npx skills add affaan-m/ecc --skill rust-testing

• agentmemory-rest-api rohitg00/agentmemory

  The agentmemory HTTP REST API surface, the primary protocol for talking to the memory server. Use when calling agentmemory over HTTP, when MCP is unavailable and you need a fallback, or when integrating a host that does not speak MCP.

  9.991 Επιτυχής npx skills add rohitg00/agentmemory --skill agentmemory-rest-api

• shopify-customer shopify/shopify-ai-toolkit

  Write and validate GraphQL operations for developers integrating Shopify's Customer Account API. Generates code for Customer Account API integrations.

  9.936 Επιτυχής npx skills add shopify/shopify-ai-toolkit --skill shopify-customer

• jpa-patterns affaan-m/ecc

  JPA/Hibernate patterns for entity design, relationships, query optimization, transactions, auditing, indexing, pagination, and pooling in Spring Boot. Use when designing JPA entities or relationships, or when a Hibernate query, transaction, or N+1 problem needs fixing.

  9.894 Επιτυχής npx skills add affaan-m/ecc --skill jpa-patterns

• rust-patterns affaan-m/ecc

  Idiomatic Rust patterns, ownership, error handling, traits, concurrency, and best practices for building safe, performant applications. Use when writing or reviewing Rust code and ownership, error handling, traits, or concurrency is in question.

  9.580 Επιτυχής npx skills add affaan-m/ecc --skill rust-patterns

• django-verification affaan-m/ecc

  Run the full Django verification loop — environment check, mypy/ruff/black linting, migration safety, pytest with coverage targets, pip-audit and bandit security scans, settings and logging review, and diff review — producing a phased pass/fail report before release or PR. Use when preparing a Django pull request, validating migrations or coverage, or running pre-deploy readiness checks.

  9.567 Επιτυχής npx skills add affaan-m/ecc --skill django-verification

• laravel-tdd affaan-m/ecc

  Laravel testing strategies with PHPUnit, Pest, model factories, HTTP tests, Sanctum authentication testing, mocking, and coverage. Use when writing Laravel tests with PHPUnit or Pest, or driving a Laravel feature test-first.

  9.553 Επιτυχής npx skills add affaan-m/ecc --skill laravel-tdd

• springboot-verification affaan-m/ecc

  Run the full Spring Boot verification loop — Maven or Gradle build, SpotBugs, PMD, and Checkstyle static analysis, unit and Testcontainers integration tests with JaCoCo coverage, OWASP dependency and secret scans, and diff review — producing a pass/fail readiness report. Use when preparing a Spring Boot pull request, validating coverage thresholds, or running pre-deploy verification.

  9.482 Επιτυχής npx skills add affaan-m/ecc --skill springboot-verification

• nextjs-turbopack affaan-m/ecc

  Next.js 16+ and Turbopack guidance — incremental Rust bundling, file-system caching, faster dev startup and HMR, Turbopack vs webpack tradeoffs, and the middleware.ts to proxy.ts filename change. Use when developing or debugging Next.js 16+ apps, diagnosing slow dev startup or hot reload, choosing between bundlers, or reviewing middleware/proxy file naming.

  9.433 Επιτυχής npx skills add affaan-m/ecc --skill nextjs-turbopack

• gemini-interactions-api google/skills

  Guides the usage of Gemini Interactions API on Gemini Enterprise Agent Platform. Use when the user wants to use the stateful, server-managed Interactions API for multi-turn conversations, background execution, streaming, structured output, and function calling on the Agent Platform.

  9.354 Επιτυχής npx skills add google/skills --skill gemini-interactions-api

• mcp-server-patterns affaan-m/ecc

  Build MCP servers with Node/TypeScript SDK — tools, resources, prompts, Zod validation, stdio vs Streamable HTTP. Use Context7 or official MCP docs for latest API. Use when building or debugging an MCP server — tools, resources, prompts, validation, or transport choice.

  8.817 Επιτυχής npx skills add affaan-m/ecc --skill mcp-server-patterns

• typespec-api-operations github/awesome-copilot

  Add GET, POST, PATCH, and DELETE operations to a TypeSpec API plugin with proper routing, parameters, and adaptive cards

  8.771 Επιτυχής npx skills add github/awesome-copilot --skill typespec-api-operations

• swift-mcp-server-generator github/awesome-copilot

  Generate a complete Model Context Protocol server project in Swift using the official MCP Swift SDK package.

  8.760 Επιτυχής npx skills add github/awesome-copilot --skill swift-mcp-server-generator

• api-security-best-practices sickn33/agentic-awesome-skills

  Implement secure API design patterns including authentication, authorization, input validation, rate limiting, and protection against common API vulnerabilities

  8.742 Επιτυχής npx skills add sickn33/agentic-awesome-skills --skill api-security-best-practices

• typespec-create-api-plugin github/awesome-copilot

  Generate a TypeSpec API plugin with REST operations, authentication, and Adaptive Cards for Microsoft 365 Copilot

  8.699 Επιτυχής npx skills add github/awesome-copilot --skill typespec-create-api-plugin

• nestjs-patterns affaan-m/ecc

  NestJS architecture patterns for modules, controllers, providers, DTO validation, guards, interceptors, config, and production-grade TypeScript backends. Use when building or reviewing a NestJS backend — modules, providers, DTO validation, guards, or interceptors.

  8.675 Επιτυχής npx skills add affaan-m/ecc --skill nestjs-patterns

• msw-search msw-git/msw-ai-coding-plugins-official

  MSW search integration — (1) vector search for API docs and implementation guides via the msw-mcp MCP server (mlua_api_retriever / mlua_document_retriever), (2) REST API search for resources (sprite / animation / sound / resource pack / avatar). Use for 'find details, examples, or related APIs not in .d.mlua', 'need a SpriteRUID', 'monster sprite', 'background image', 'find a sound', 'avatar item lookup', etc. Keywords: document search, API details, examples, guide, retriever, resource, sprite, animation, sound, RUID, resource pack, avatar.

  8.435 Επιτυχής npx skills add msw-git/msw-ai-coding-plugins-official --skill msw-search

• gemini-agents-api google/skills

  Manages custom Agent resources on Gemini Enterprise Agent Platform. Use when the user wants to programmatically create, configure, list, update, or delete stateful, server-managed Agent resources (including mounting files, skills, and tools) before executing conversations.

  8.419 Επιτυχής npx skills add google/skills --skill gemini-agents-api

• laravel-verification affaan-m/ecc

  Verification loop for Laravel projects: env checks, linting, static analysis, tests with coverage, security scans, and deployment readiness. Use when verifying a Laravel project before merge or deploy — lint, static analysis, tests, coverage, security.

  8.340 Επιτυχής npx skills add affaan-m/ecc --skill laravel-verification

• flutter-interoperating-with-native-apis flutter/agent-plugins

  8.277 Επιτυχής npx skills add flutter/agent-plugins --skill flutter-interoperating-with-native-apis

Οι περιγραφές είναι των ίδιων των δημιουργών, στα αγγλικά. Διαβάστε τον κώδικα ενός skill στο αποθετήριό του πριν το εγκαταστήσετε.