🎯Skills4
🔌Plugins20
Frontend web development with Bun, Astro, React, Preact, Tailwind CSS v4, and Shadcn UI. ALWAYS use this skill when the user's task involves frontend or web UI work — building websites, web apps, landing pages, dashboards, components, or pages. This includes: Astro islands architecture, React or Preact components, Tailwind styling, Shadcn UI setup, frontend testing with Playwright and Lightpanda, accessibility, web performance, forms, data tables, static sites, SSR, View Transitions, content collections, MDX, deployment to Vercel/Netlify/Cloudflare, or any task mentioning .astro/.tsx/.jsx files, CSS utilities, or frontend build tooling. Even if the user just says "build me a page" or "create a website" — use this skill.
Building command-line tools in Go with the stdlib `flag` package. ALWAYS use this skill when writing or reviewing Go CLI code — top-level flags with `flag.Parse`, subcommands with `flag.NewFlagSet`, exit codes, writing errors to `os.Stderr`, signal handling, environment-variable fallbacks, `-h`/`-help` output, and `cmd/<tool>` project layout. Avoid reaching for cobra/urfave-cli unless the tool clearly needs it (~5+ subcommands with rich help). Pair with go-style for naming and config patterns, go-errors for exit-code mapping, and go-logging for diagnostic output.
Disciplined Go concurrency. ALWAYS use this skill when writing or reviewing Go code that touches goroutines, channels, `context.Context`, `sync.WaitGroup`, `sync.Mutex` / `sync.RWMutex`, `sync.Once`, `errgroup.Group`, worker pools, fan-out/fan-in pipelines, request cancellation, timeouts, deadlines, or any "run this in the background" pattern. Also use when debugging deadlocks, goroutine leaks, race conditions, or channel-related bugs. Pair with go-errors for error propagation across goroutines.
Writing, reviewing, refactoring, debugging, or designing Go code — backends, microservices, APIs, CLI tools, daemons, workers, data pipelines, libraries. Umbrella router that delegates to focused sibling Go skills.
Idiomatic Go error handling. ALWAYS use this skill when writing or reviewing Go code that raises, returns, wraps, matches, or aggregates errors — questions about `fmt.Errorf` with `%w` vs `%v`, `errors.Is` and `errors.As`, sentinel errors, typed error structs, `errors.Join` for combining failures, the "handle exactly once" rule, panic vs error, guard clauses and early return, error message formatting, or any `if err != nil` pattern. Use alongside go-style for general idioms.
Building HTTP services in Go with the Chi router and stdlib `net/http`. ALWAYS use this skill when writing or reviewing Go HTTP code — defining routes with `chi.Router`, middleware (`chi.Use`, `middleware.Logger`, `middleware.Recoverer`, `middleware.RequestID`), handler signatures, request decoding, JSON responses, status codes from typed errors, graceful shutdown with `http.Server.Shutdown`, `httptest` patterns, service project layout (`cmd/server`, `internal/handler`, `internal/service`), and timeouts (`ReadTimeout`, `WriteTimeout`, `IdleTimeout`). Pair with go-sql for the data layer, go-logging for request-scoped logging, go-errors for status code mapping, and go-testing for handler tests.
Linting and formatting Go code with `gofmt`, `goimports`, `golangci-lint`, and a curated `.golangci.yml`. ALWAYS use this skill when setting up or troubleshooting Go linting — installing golangci-lint, dropping the bundled `.golangci.yml` into a project, configuring pre-commit hooks, picking which linters to enable (errcheck, govet, staticcheck, unused, misspell, prealloc, gosec, revive, gocritic), suppressing findings with `//nolint` comments, reading lint output, or wiring lint into CI. Pair with go-style for the underlying idioms most lint rules enforce.
Structured logging in Go with `log/slog` (Go 1.21+ stdlib). ALWAYS use this skill when adding, reviewing, or debugging logging in Go — choosing a logger, configuring `slog.NewJSONHandler` / `slog.NewTextHandler`, injecting `*slog.Logger` as a dependency, using `slog.With`, `slog.Group`, `LogValuer` for lazy values, propagating loggers through `context.Context`, picking log levels (info/debug/warn/error), or designing observability patterns (USE method, RED method). Pair with go-http for request-scoped logging middleware and go-errors for the "log or return, not both" rule.
Type-safe SQL access in Go with sqlc and goose migrations. ALWAYS use this skill when writing or reviewing Go database code — `sqlc.yaml` configuration, query annotations (`:one`, `:many`, `:exec`, `:execrows`), generated `Querier` interface for mocking, goose Up/Down migrations, transaction patterns with `BEginTx` and `db.WithTx`, `pgx`/`pgxpool` vs `database/sql`, `sql.ErrNoRows` handling, JSON columns, and testing the data layer. Pair with go-http for the service-handler-storage stack, go-errors for wrapping `sql.ErrNoRows`, and go-testing for `Querier` mocking.
Idiomatic Go style: naming, package and file organization, interfaces, documentation, generics, iterators, range-over-int, performance, dependency management, and common pitfalls. ALWAYS use this skill when writing or reviewing Go code for general style and idioms — questions about naming conventions, where to put a type, when to use generics vs `any`, how to size interfaces, godoc comments, the `internal/` package, struct literal initialization, slice/map gotchas, loop-variable capture, defer timing, or "is this idiomatic Go?". Pair with go-errors, go-concurrency, go-testing, go-logging, go-http, go-cli, go-sql, or go-lint when those concerns dominate the task.
Idiomatic Go testing with the stdlib `testing` package and the go-testdeep assertion library. ALWAYS use this skill when writing or reviewing Go tests — table-driven tests with `map[string]testCase`, `t.Run` subtests, `t.Helper()` for assertion helpers, `t.Cleanup`, `t.Parallel`, integration test gating with environment variables, benchmarks (`testing.B`), fuzz tests, go-testdeep operators (`td.Cmp`, `td.CmpError`, `td.CmpNoError`, `td.Struct`, `td.Smuggle`, `td.Between`, `td.Re`, `td.Require`), and the third-party-frameworks debate (go-testdeep when deps are allowed, stdlib-only for dependency-free projects, never testify). Pair with go-sql for testing DB code with sqlc's `Querier` interface, go-http for `httptest` patterns, and go-concurrency for race-detector usage.
Integrate the Kinde auth platform (single sign-on, OAuth 2.0 / OIDC, organizations, RBAC, feature flags, M2M, management API) into Go and TypeScript applications. ALWAYS use this skill when the user mentions Kinde, docs.kinde.com, a kinde.com subdomain, the @kinde-oss or @kinde packages, kinde-typescript-sdk, kinde-auth-nextjs, kinde-oss/kinde-go, or asks to wire up login/logout/callback, validate Kinde JWTs, call the Kinde management API, gate features on Kinde flags, or build machine-to-machine auth against Kinde. Covers the Authorization Code (+ PKCE) flow, Client Credentials (M2M) flow, Device flow, token refresh, JWKS validation, organizations and multi-tenancy, roles and permissions, and feature flags. Go and TypeScript are first-class; the OAuth-without-an-SDK guidance also applies to any language that speaks HTTP and JWT.
Comprehensive landing page design analysis for extracting typography, color palette, spacing systems, visual elements, and conversion optimization insights. Use when a user provides a landing page URL for design analysis, wants to understand what makes a page effective, needs to extract design specifications, or wants to learn from high-converting landing pages.
Manage multi-agent AI code configurations across platforms (OpenAI Codex, Claude Code, Cursor, Gemini). Use when: (1) initializing new multi-agent projects, (2) syncing configurations (MCP servers, skills, rules, subagents) across platforms, (3) translating configurations between different agent platforms, (4) migrating from one agent platform to another, or (5) maintaining consistent agent configurations across development teams using different tools.
Production-grade SQLite for web, mobile, and CLI projects. Use this skill when designing schemas, tuning PRAGMAs (WAL, busy_timeout, mmap, optimize), modeling writer concurrency (single-writer pool, BEGIN IMMEDIATE, busy retry), building indexes (covering, partial, expression, STRICT, WITHOUT ROWID), paginating with keyset cursors, implementing job queues via `UPDATE ... RETURNING`, full-text search with FTS5 + sqlite-vec, replicating with Litestream / Turso / Cloudflare D1, picking a driver (better-sqlite3, modernc.org/sqlite, GRDB, Room, SQLDelight, expo-sqlite, SQLCipher), or running the 12-step `ALTER TABLE` rewrite. Pair with go-sql for sqlc + goose against SQLite, apple-dev for GRDB on iOS, and front-dev for in-browser SQLite via OPFS.
Design production-grade software systems with expert knowledge of architecture patterns, distributed systems, cloud platforms, and operational excellence. Use this skill when architecting complex systems, evaluating technology choices, designing scalable infrastructure, or making critical architectural decisions requiring trade-off analysis.
Capture tasks into Things 3 on macOS via the things:/// URL scheme. ALWAYS use this skill when the user mentions Things (the Cultured Code app), Things 3, Things Inbox, or asks to add/create/capture to-dos, tasks, reminders, or todos in Things. Also use when the user invokes the /mytodo slash command, dictates a stream-of-consciousness list they want turned into tasks, or asks to push items to Things by project or area. Covers: generalizing free text into atomic to-dos, batch-adding via things:///json, scheduling (today, anytime, someday, specific date), targeting projects or areas, tags, and checklist items. Not for other to-do apps — if the user mentions Reminders, Todoist, OmniFocus, or anything non-Things, do not use this skill.
Browser automation, web testing, and page interaction driven from the command line with `playwright-cli`, defaulting to the Lightpanda headless browser. ALWAYS use this skill when the agent needs a browser — opening pages, navigating, clicking/typing/filling forms, taking snapshots or screenshots, scraping or reading page content, logging in, running or debugging Playwright tests, mocking network requests, managing cookies / localStorage / storage state, recording traces or video, or generating tests. The agent defaults to Lightpanda (installed locally and driven over CDP) without asking, and switches to Chromium, Chrome, Firefox, WebKit, or Microsoft Edge only when the user asks. Falls back to a full browser when Lightpanda cannot render a page.
Comprehensive macOS and iOS development expertise covering Swift best practices, SwiftUI design patterns, Human Interface Guidelines, Apple frameworks, and performance optimization. Use when developing native Apple applications, implementing SwiftUI interfaces, working with Apple frameworks (Foundation, UIKit, AppKit, Core Data, CloudKit, etc.), optimizing app performance, following HIG principles, or writing production-quality Swift code for iOS, macOS, watchOS, or tvOS platforms.
Professional copywriter for SaaS and startups. Expert in landing page copy, positioning, messaging, conversion optimization, and voice-of-customer research. Use when writing compelling copy for SaaS products, landing pages, marketing materials, or when you need help with product positioning and messaging strategy.