all publishers

context-labs

@context-labs source repo

56 published skills

  1. ▌
    New Feature Development 2 · context-labs bundle
    The end-to-end playbook for building a NET-NEW feature in the inference monorepo — the umbrella that turns "I want to build X" into shipped, observable, well-tested, service-pattern-compliant code. Use this whenever the user wants to add a feature, endpoint, page, service, queue consumer, cron, or capability ("build…", "add…", "implement…", "we need a way to…", "spec out…", "let's ship…", "wire up…", "expose…"), even if they don't say the word "feature", and even if they hand you a half-formed idea. It clarifies ambiguity first, grounds the work in the product's first principles, writes a living plan in `.ai-docs/`, delegates implementation across a diverse set of models, keeps the code observable and functional, runs the test + `task check` gates, and drives adversarial review. Prefer this skill over jumping straight into code for anything larger than a one-file change. Do NOT use it for pure debugging of an existing bug (use `fixing-a-bug`), ops/infra queries, or narrow scaffolds already owned by a dedicate
    958 repo stars
  2. ▌
    Golang CLI · context-labs bundle
    Golang CLI development — command structure, flags, config layering, exit codes, I/O, signals, shell completion, validation, testing. Use when building or reviewing a Go CLI or code using cobra, viper, urfave/cli. Cobra → `golang-spf13-cobra`; viper → `golang-spf13-viper`.
    958 repo stars
  3. ▌
    Golang Grpc · context-labs bundle
    gRPC usage, protobuf organization, and production patterns for Go 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 streaming RPCs.
    958 repo stars
  4. ▌
    Golang Lint · context-labs bundle
    Linting best practices and golangci-lint configuration for Go — running linters, configuring .golangci.yml, nolint suppressions, selecting linters. Use when setting up golangci-lint or code quality tooling, handling lint warnings or nolint, or when go vet, staticcheck, or revive are mentioned.
    958 repo stars
  5. ▌
    Golang Gopls · context-labs bundle
    Golang semantic code intelligence via `gopls` — go-to-definition, references, call hierarchy, symbols, diagnostics, rename, refactors. Use when navigating or refactoring Go code. Not for published ecosystem → `golang-pkg-go-dev`; vuln audits → `golang-security`.
    958 repo stars
  6. ▌
    Golang How To · context-labs bundle
    Golang skills orchestrator — always active on any Go coding, review, debug, or setup task. Loads the most relevant samber/cc-skills-golang skills, disambiguating overlapping clusters. Configures agent-config files (CLAUDE.md, AGENTS.md, GEMINI.md, Cursor, Copilot) to force-trigger skills.
    958 repo stars
  7. ▌
    Golang Naming · context-labs bundle
    Go naming conventions — packages, constructors, structs, interfaces, enums, errors, receivers, getters/setters, acronyms, tests. Use when writing/reviewing Go code or picking between naming alternatives (New vs NewTypeName, ErrNotFound vs NotFoundError). Not for non-naming Go questions.
    958 repo stars
  8. ▌
    Golang Safety · context-labs bundle
    Defensive Go coding to prevent panics, silent data corruption, and subtle runtime bugs. Use for nil panics, append aliasing, concurrent map access, float comparison pitfalls, zero-value design; or when reviewing for nil-safety, numeric overflow, defer in loops, or defensive copying of slices/maps.
    958 repo stars
  9. ▌
    Golang Context · context-labs bundle
    Idiomatic context.Context usage in Golang — cancellation, timeouts/deadlines, request-scoped values, WithoutCancel for background work. Use when designing context propagation across layers, debugging leaked contexts, or choosing Background/TODO/WithoutCancel. Not for code merely accepting ctx.
    958 repo stars
  10. ▌
    Golang GRAPHQL · context-labs bundle
    GraphQL APIs in Go using gqlgen or graphql-go. Apply when building GraphQL servers, designing schemas, writing resolvers, handling subscriptions, or integrating GraphQL with Go HTTP services. Also when the codebase imports `github.com/99designs/gqlgen` or `github.com/graph-gophers/graphql-go`.
    958 repo stars
  11. ▌
    Golang Swagger · context-labs bundle
    Golang OpenAPI/Swagger docs with swaggo/swag — annotations (@Summary, @Param, @Success, @Router, @Security), swag init, framework integrations (gin, echo, fiber, chi), security definitions, struct tags. Apply when adding/maintaining Swagger docs in Go or the codebase imports github.com/swaggo/*.
    958 repo stars
  12. ▌
    Golang Testing · context-labs bundle
    Production-ready Golang tests — table-driven, testify suites/mocks, parallel tests, fuzzing, fixtures, goleak leak detection, snapshots, coverage, integration tests. Use when writing/reviewing Go tests, choosing an approach, test CI, or debugging flakes. Testify: golang-stretchr-testify.
    958 repo stars
  13. ▌
    Golang Uber Fx · context-labs bundle
    Golang application framework using uber-go/fx — fx.New, fx.Provide, fx.Invoke, fx.Module, fx.Lifecycle hooks, fx.Annotate, fx.Decorate, fx.Supply, signal-aware Run(). Apply when using/adopting fx or the codebase imports go.uber.org/fx. Raw DI without lifecycle → golang-uber-dig.
    958 repo stars
  14. ▌
    Golang Database · context-labs bundle
    Go database access — parameterized queries, struct scanning, NULLable columns, transactions, isolation levels, SELECT FOR UPDATE, connection pool, migrations. Use for PostgreSQL, MariaDB, MySQL, SQLite; database testing; or database/sql, sqlx, pgx. Does NOT generate schemas or migrations.
    958 repo stars
  15. ▌
    Golang Security · context-labs bundle
    Security best practices for Golang — injection (SQL, command, XSS), cryptography, filesystem safety, network security, cookies, secrets, memory safety, logging. Apply when writing, reviewing, or auditing Go code for security, or on risky code involving crypto, I/O, secrets, user input, auth.
    958 repo stars
  16. ▌
    Golang Uber Dig · context-labs bundle
    Dependency injection in Golang using uber-go/dig — reflection container, Provide/Invoke, dig.In/dig.Out objects, named values, value groups, optional deps, scopes. Apply when using/adopting dig or on go.uber.org/dig imports. Lifecycle → golang-uber-fx.
    958 repo stars
  17. ▌
    Golang Benchmark · context-labs bundle
    Golang benchmarking, profiling, and performance measurement. Use when writing or comparing Go benchmarks, profiling with pprof, interpreting CPU/memory/trace profiles, benchstat analysis, CI benchmark regression detection, or production performance issues. For optimizations → `golang-performance`.
    958 repo stars
  18. ▌
    Golang Modernize · context-labs bundle
    Modernize Go code to recent language features, standard library improvements, and idiomatic patterns. Trigger proactively when writing or reviewing Go code with old-style patterns or a deprecation warning, or when the user asks for modernization, a Go version upgrade, or a CI/tooling refresh.
    958 repo stars
  19. ▌
    Golang Samber Do · context-labs bundle
    Dependency injection in Go using samber/do — service containers, lifecycle, scopes, health checks, graceful shutdown, module organization. Apply when using or adopting samber/do, when the codebase imports github.com/samber/do(/v2), or when refactoring constructor injection into a DI container.
    958 repo stars
  20. ▌
    Golang Samber Lo · context-labs bundle
    Functional helpers for Go using samber/lo — 500+ type-safe generics for slices, maps, strings, concurrency (Map, Filter, Reduce); concurrent (lo/parallel), in-place (lo/mutable), lazy iterators (lo/it). Apply when using/importing github.com/samber/lo. Not for streaming (→ golang-ro).
    958 repo stars
  21. ▌
    Golang Samber Mo · context-labs bundle
    Monadic types in Golang via samber/mo — Option, Result, Either, Future, IO, Task, State for type-safe nullable values, error handling, functional composition. Apply when using/adopting samber/mo, when the codebase imports github.com/samber/mo, or for functional patterns as a safety design.
    958 repo stars
  22. ▌
    Golang Samber Ro · context-labs bundle
    Reactive streams in Golang using samber/ro — ReactiveX with 150+ operators, cold/hot observables, subjects, Pipe pipelines, backpressure. Apply when using/adopting samber/ro, when the codebase imports it, or building async event pipelines. Not for finite slice transforms (golang-samber-lo).
    958 repo stars
  23. ▌
    Golang Pkg Go Dev · context-labs bundle
    Golang package/module docs via `godig`, a pkg.go.dev API client (CLI + MCP) — APIs, symbols, versions, importers, licenses, vulnerabilities. Use to look up Go library docs, signatures, or CVEs — prefer over Context7. Not for deps, library choice, local symbols (→ golang-gopls).
    958 repo stars
  24. ▌
    Golang Samber Hot · context-labs bundle
    In-memory caching in Go using samber/hot — eviction (LRU, LFU, TinyLFU, S3FIFO, ARC, SIEVE), TTL, loaders, sharding, stale-while-revalidate, missing-key caching, metrics. Apply when using samber/hot, on github.com/samber/hot imports, or to cut latency on hot keys.
    958 repo stars
  25. ▌
    Golang Concurrency · context-labs bundle
    Golang concurrency patterns. Use when writing or reviewing concurrent Go code — goroutines, channels, select, locks, sync primitives, errgroup, singleflight, worker pools, fan-out/fan-in — or for goroutine leaks, race conditions, channel ownership, or choosing channels vs mutexes.
    958 repo stars
  26. ▌
    Golang Google Wire · context-labs bundle
    Compile-time dependency injection in Golang using google/wire — wire.NewSet, wire.Build, wire.Bind, wire.Struct, wire.FieldsOf, cleanup, wireinject, wire_gen.go. Apply when using google/wire, when code imports `github.com/google/wire`, or wiring at compile time. Runtime DI → `golang-uber-dig`.
    958 repo stars
  27. ▌
    Golang Performance · context-labs bundle
    Go performance optimization — if X bottleneck, apply Y: allocation reduction, CPU/memory efficiency, GC tuning, pooling, caching, hot paths. Use when a profiled/benchmarked bottleneck needs the fix pattern. Not for measurement (→ golang-benchmark) or debugging (→ golang-troubleshooting).
    958 repo stars
  28. ▌
    Golang Refactoring · context-labs bundle
    Golang refactoring — safe restructuring at scale: safety-net tests, tool-driven transforms (gopls Rename/Inline/Extract, `gofmt -r`), import cycles, stacked PRs. Apply for code smells, renames, extracting functions/interfaces, splitting packages. Styles → golang-naming, -modernize.
    958 repo stars
  29. ▌
    Golang Samber Oops · context-labs bundle
    Structured error handling in Golang with samber/oops — error builders, stack traces, codes, context, wrapping, attributes, user-facing vs developer messages, panic recovery, logger integration. Apply when using/adopting samber/oops or the codebase imports github.com/samber/oops.
    958 repo stars
  30. ▌
    Golang Samber Slog · context-labs bundle
    Structured logging extensions for Golang using samber/slog-* — multi-handler pipelines, sampling, attribute formatting, HTTP middleware (gin, echo, fiber, chi), backend routing (datadog, sentry, loki, syslog). Apply when using slog or on github.com/samber/slog-* imports.
    958 repo stars
  31. ▌
    Golang Spf13 Cobra · context-labs bundle
    CLI command tree library for Golang using spf13/cobra — cobra.Command, RunE vs Run, PreRun hooks, Args validators, persistent vs local flags, shell completion, testing via SetArgs. Apply when using/adopting cobra or the codebase imports github.com/spf13/cobra. Config: golang-spf13-viper.
    958 repo stars
  32. ▌
    Golang Spf13 Viper · context-labs bundle
    Golang configuration library using spf13/viper — layered precedence (flag > env > file > KV > default), AutomaticEnv, ReadInConfig, Unmarshal + mapstructure, WatchConfig hot reload. Apply when using/adopting viper or the codebase imports github.com/spf13/viper. CLI commands: golang-spf13-cobra.
    958 repo stars
  33. ▌
    Golang Observability · context-labs bundle
    Go observability — always-on production signals: slog logging, Prometheus metrics, OpenTelemetry tracing, pprof profiling, alerting, Grafana. Apply when instrumenting Go services or migrating zap/logrus/zerolog to slog. Not for performance deep-dives (→ golang-benchmark, golang-performance).
    958 repo stars
  34. ▌
    Golang Error Handling · context-labs bundle
    Idiomatic Golang error handling — %w wrapping, errors.Is/As, errors.Join, custom and sentinel errors, panic/recover, single handling rule, slog logging, samber/oops. Apply when creating, wrapping, inspecting, or logging errors. oops → `golang-samber-oops`; slog → `golang-samber-slog`.
    958 repo stars
  35. ▌
    Golang Project Layout · context-labs bundle
    Golang project layouts and workspaces. Use when starting a new Go project, organizing an existing codebase, setting up a monorepo, creating CLI tools with multiple main packages, deciding between cmd/internal/pkg conventions, or discussing package restructuring, package splits, or module splits.
    958 repo stars
  36. ▌
    Golang Data Structures · context-labs bundle
    Golang data structures — slices/maps internals (capacity growth, preallocation, hash buckets), slices/maps packages, container/list/heap/ring, strings.Builder vs bytes.Buffer, generic collections, unsafe/weak pointers. Use when choosing or optimizing Go data structures or slice/map internals.
    958 repo stars
  37. ▌
    Golang Design Patterns · context-labs bundle
    Idiomatic Golang design patterns — functional options, constructors, error flow, resource lifecycle, graceful shutdown, resilience, architecture, dependency injection, streaming. Apply when choosing architectural patterns, implementing functional options, or asking which Go pattern fits.
    958 repo stars
  38. ▌
    Golang Troubleshooting · context-labs bundle
    Troubleshoot Golang programs — find and fix the root cause. Use for bugs, crashes, deadlocks, or unexpected behavior in Go code. Covers debugging methodology, pitfalls, pprof, Delve, race detection, GODEBUG. Start here for 'something is wrong'. Not for benchmarks or optimization.
    958 repo stars
  39. ▌
    Golang Stretchr Testify · context-labs bundle
    Golang testing with stretchr/testify — assert, require, mock, suite: assertions, mock expectations, argument matchers, suite lifecycle, Eventually, JSONEq. Use when writing testify tests, creating mocks, choosing assert vs require, or when the codebase imports github.com/stretchr/testify.
    958 repo stars
  40. ▌
    Golang Structs Interfaces · context-labs bundle
    Golang struct and interface design — composition, embedding, type assertions, type switches, DI via interfaces, field tags, pointer vs value receivers. Use when designing Go types, implementing interfaces, embedding, adding JSON/YAML/DB tags, or 'accept interfaces, return structs'.
    958 repo stars
  41. ▌
    Golang Dependency Injection · context-labs bundle
    Dependency injection (DI) in Golang — why DI matters, manual constructor injection, library comparison. Use when designing service architecture or wiring dependencies. For google/wire, dig, fx, samber/do → `golang-google-wire`, `golang-uber-dig`, `golang-uber-fx`, `golang-samber-do`.
    958 repo stars
  42. ▌
    Golang Dependency Management · context-labs bundle
    Golang dependency management — go.mod, installing/upgrading packages, Minimal Version Selection, vulnerability scanning, binary size, Dependabot/Renovate, conflict resolution, go.work. Use when adding, removing, upgrading dependencies, auditing vulnerabilities, or automating updates.
    958 repo stars
  43. ▌
    Golang Continuous Integration · context-labs bundle
    CI/CD with GitHub Actions for Golang — testing, linting, SAST, security scanning, coverage, Dependabot, Renovate, GoReleaser, release pipelines. Use when setting up Go project CI, GitHub Actions workflows, linters/scanners, dependency update automation, or quality gates.
    958 repo stars
  44. ▌
    Halo Loop · context-labs
    Use HALO Engine as a diagnostic aid to iteratively improve an agent harness. Engine surfaces patterns from traces; Claude maps findings to code, makes the smallest sensible change, re-runs, and measures.
    958 repo stars
  45. ▌
    Lsptkns · context-labs
    Use the lsptkns CLI for semantic code analysis via Language Server Protocol. Use this skill whenever you need to find symbol definitions, trace references across a codebase, list all symbols in a project, inspect class/function internals, build call graphs, or diff code structure between versions. Trigger on tasks like: 'find where X is defined', 'what calls this function', 'show me all the classes', 'how does this module connect to that one', 'what changed between these two snapshots'. Also use when the user mentions lsptkns directly, or when semantic code understanding would be more accurate than grep/ripgrep text search.
    958 repo stars
  46. ▌
    I Have Adhd · context-labs bundle
    Shape output for a reader with ADHD: lead with the next action, number multi-step work, restate state across turns, suppress tangents, give specific time estimates, make wins visible. Invoke with /i-have-adhd; stays on until "stop adhd mode".
    958 repo stars
  47. ▌
    Fixing A Bug · context-labs
    The disciplined playbook for fixing a bug in the clocked-in repo — reproduce and root-cause BEFORE changing code, prove it with a failing test, fix at the right layer, verify the gate, then clean up. Use whenever something is broken or wrong ("X isn't recording", "the report is off", "the hook crashed/hung", "install clobbered my hooks", "this regressed", a pasted stack trace or wrong number) — i.e. making existing behavior correct again, not building something new (that's new-feature-development). Pulls in running-tests to reproduce, multi-model-orchestration to delegate/cross-check the fix, and /adversarial-code-review + /ponytail-review to clean up.
    958 repo stars
  48. ▌
    Running Tests · context-labs
    How to run and debug tests in the clocked-in repo — a small Bun CLI. Covers `bun test`, the `task check` gate (tsgo + oxlint + oxfmt + tests), running a single file or test, how DB/HOME isolation works, the committed-bundle rebuild gotcha, and end-to-end checks (hook → report, the Ink TUI in a pty, a real opencode run). Use whenever the user asks to run tests, verify a change, reproduce a failure, or mentions "unit test", "task check", "test hangs", or "test fails".
    958 repo stars
  49. ▌
    Adversarial Code Review · context-labs bundle
    Adversarial multi-model code review that finds real defects, proves them, and fixes them. Every available model family (grok, codex, claude — including the one hosting this session) reviews the diff independently and blind; every finding is then cross-examined by a lane that did not raise it, so nothing survives on one model's say-so. Confirmed behavioral defects get a failing test before the fix and a passing one after; confirmed structural problems get fixed with the suite staying green as the proof behavior did not change. Use whenever the user asks for a hard, thorough, adversarial, multi-model, or cross-vendor review — "review my branch with multiple models", "tear this apart", "adversarial review", "have grok and codex check this", "find the real bugs and fix them with tests", "second opinion from another model on this diff" — or wants a review that ends in verified fixes rather than a list of comments. Prefer this over a single-model review whenever correctness matters enough to pay for several model f
    958 repo stars
  50. ▌
    Multi Model Orchestration · context-labs bundle
    Vendor-neutral routing doctrine for delegating implementation work across the Claude Code, Grok, and Codex CLIs. Whichever model hosts the session acts as architect and routes typing to the other two families. Use when delegating implementation, choosing an implementation lane, writing a spec for another agent, racing two model families on the same spec, checking whether a CLI lane is usable, or managing session token cost on a multi-task build. Replaces the fable-advisor `/orchestration` plugin skill, whose auth preflight and grok flag set both produce false failures.
    958 repo stars
  51. ▌
    Ponytail · context-labs
    The lazy senior dev: write the least code that works — the ponytail ladder (does it need to exist? already here? stdlib? native? existing dep? one line?), root cause over symptom, deletion over addition, `ponytail:` comments for shortcuts. whip's default posture; /ponytail on a diff or review.
    958 repo stars
  52. ▌
    Golang Code Style · context-labs bundle
    Golang code style — line length and breaking, variable declarations, control flow clarity, when comments help vs hurt. Use when writing or reviewing Go code or setting coding standards. Not for naming (→ `golang-naming`), lint (→ `golang-lint`), docs (→ `golang-documentation`).
    958 repo stars
  53. ▌
    Golang Stay Updated · context-labs bundle
    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.
    958 repo stars
  54. ▌
    Golang Documentation · context-labs bundle
    Documentation for Golang projects — godoc comments, README, CONTRIBUTING, CHANGELOG, Go Playground, Example tests, API docs, llms.txt. Use when writing or reviewing doc comments or documentation, adding code examples, setting up doc sites, or documentation best practices. For libraries and CLIs.
    958 repo stars
  55. ▌
    New Feature Development · context-labs bundle
    Playbook for building a NET-NEW feature in whip. Use when the user wants to add a feature, tool, slash command, integration, or UX behavior ('build…', 'add…', 'implement…'), even without the word 'feature'. Mines docs/roadmap.md + docs/learnings/. NOT for debugging or narrow golang-* changes.
    958 repo stars
  56. ▌
    Golang Popular Libraries · context-labs bundle
    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.
    958 repo stars