engineering-skills

Meta-skill that routes a task to the right engineering skill. Load this at the start of a session or when unsure which skill applies — it maps intent to the process that should govern the work.

Catches breaking changes between services before they ship, by testing the contract each consumer actually depends on instead of spinning up the whole system. Use when services deploy independently, when a provider API change could break a consumer, or when end-to-end integration tests are too slow and flaky to guard every service boundary.

Proves whether a change actually moves the metric, with a valid A/B test instead of a guess — a hypothesis, a primary metric, a pre-computed sample size, guardrail metrics, and an honest readout. Use when shipping a change meant to improve a number (conversion, retention, performance), running an A/B or holdout, or deciding whether a feature "worked."

Decouples deploy from release using feature flags — ship code dark, roll out gradually, kill instantly, and remove the flag once it's done. Use when releasing risky or large changes, rolling out by percentage/cohort, delivering A/B variants, or when stale flags are accumulating as debt.

Finds security risks at design time — before code exists — by mapping the system, enumerating how it could be attacked, and deciding what to do about each threat. Use when designing a feature that touches auth, data, money, or external input, when changing a trust boundary, or when a security-sensitive change needs a structured risk pass rather than a code-level review.

Designs durable, curated memory that an agent carries across sessions — what to persist, how to scope and retrieve it, and how to stop it from drifting or poisoning later runs. Use when an agent needs to remember decisions, preferences, or project facts beyond one context window, or when stale/over-generalized memory is corrupting its behavior.

Stops an AI agent from declaring "done" on work it hasn't actually finished, by separating generation from evaluation and refusing self-graded completion. Use whenever an agent reports a task complete — especially in autonomous or long-running runs — to catch early termination, self-grading bias, and gamed tests before the work is trusted or merged.

Designs and supervises an autonomous agent loop (a /goal- or /loop-style run that prompts itself until a verifiable stop) so it ships work you can trust instead of accumulating silent errors. Use when setting up an agent to run unattended, on a schedule, or in a self-prompting cycle — and to decide when NOT to loop.

Keeps an agent (or a planner/worker/judge fleet) coherent across hours or days and thousands of model calls — using external plan and progress files, checkpoint-and-resume, and context compaction so the run survives context limits, crashes, and drift. Use when a task is too big for one context window or must run unattended over a long horizon.

Routes marketing tasks to the right skill and agent in the marketing team. Load when you need to market a product, grow traffic, write content, post on social, improve SEO, or engage a community — and you're not sure which marketing skill or agent to use.

Turns a shipped feature into a complete go-to-market launch kit — positioning, seeded community, SEO landing, launch content, a social post pack, email and referral loops, and a measurement plan — by running the marketing persona team in the correct order with gates. Use after a feature is released (post launch-readiness) when you need to actually market it, not just one blog post or tweet.

Turns a raw idea into a decision-ready discovery package — validated problem, PRD with scope and success metrics, RFC handoff, and an ordered task breakdown — by running the PM persona trio (business-analyst, product-manager, product-analyst) through the Define and Plan phases. Use at the front of a feature when you have a one-line idea and need a buildable, measurable plan before any code.

Captures a hard-won lesson from the current session back into the skill library before it evaporates. Use at the end of non-trivial work — after a tricky debug, a repeated mistake, a workflow that finally worked, or a skill that misfired or was ignored. Closes the self-improving loop by triaging the lesson and handing the keeper to skill-creator.

Drives a feature end-to-end through the full lifecycle — define, plan, build, verify, review, ship — loading the right skill and persona at each phase, gating on sign-off, and dispatching independent work to parallel subagents. Use for any non-trivial feature or project, not a single small edit.

Dispatches independent tasks to parallel subagents and integrates their results for faster, focused execution. Use when a plan has multiple independent tasks, or a task is large enough to delegate to a fresh focused agent.

Builds UI that everyone can use — keyboard, screen reader, low vision, reduced motion, and motor differences. Use when creating or changing any user-facing interface, implementing custom widgets, fixing a11y bugs, or preparing for an audit.

Always-on safety boundaries for AI agents — blocks destructive data operations, secret exfiltration, and security-breaking actions unless the user explicitly approves. Load at every session start and before any tool use that touches data, credentials, or production systems.

Verifies web changes by exercising them in a real browser with DevTools — console, network, interaction, states, and layout. Use after any UI or front-end change, when debugging browser-only bugs, or before claiming a web change is done.

Adds caching that speeds reads without serving stale or wrong data. Use when a read is expensive and repeated, when adding or tuning a cache layer, or when debugging stale-data and invalidation bugs.

Manages what information an AI agent works from so context stays relevant, grounded, and small. Use when a task spans many files, when responses drift or hallucinate, when writing project rules or agent instructions, when a long session degrades, or when designing prompts and agent tools that carry context.

Designs data schemas and queries that stay correct and fast as data grows. Use when creating or changing a database schema, designing tables/collections, adding indexes, fixing slow queries, planning backfills, or choosing how data is stored and accessed at scale.

Captures architectural decisions and the reasoning behind them (ADRs) and keeps docs useful. Use when making a significant technical choice, recording what an RFC or experiment decided, when documentation is missing, stale, or misleading, or when future maintainers will ask "why not X?"

Manages third-party dependencies safely — vetting, pinning, updating, and supply-chain risk. Use when adding a library, upgrading or removing one, reacting to a security advisory, auditing what a project pulls in, or reviewing a PR that changes the dependency tree.

Turns a visual design into faithful, maintainable front-end code. Use when implementing a mockup or Figma file, matching a design spec, building against a design system, or reviewing how closely an implementation tracks its design.

Writes and runs end-to-end tests that prove critical user flows work in a real browser. Use when unit tests pass but user journeys need verification, before release of UI flows, or when regressions happen only in full-stack integration.

A disciplined method for debugging and recovering from failures. Use when something breaks, behaves unexpectedly, a test fails, an error appears, or a bug is intermittent — instead of guessing at fixes or stacking random edits.

Controls cloud and SaaS spend — cost visibility, budgets, alerts, and right-sizing. Use when bills spike, planning infra for a feature, or setting cost guardrails before scale.

Sound git practice — focused commits, clear messages, clean branches, safe history. Use when committing, branching, opening or updating a PR, merging, resolving conflicts, cutting a release, or recovering from a git mistake.

Applies security fundamentals — input validation, authorization, secret handling, and safe defaults. Use when handling untrusted input, auth, sensitive data, webhooks, LLM prompts, file uploads, or reviewing code for vulnerabilities.

Internationalizes and localizes products — strings, locales, formats, RTL, and translation workflow. Use when adding languages, fixing locale bugs, or expanding to non-English markets.

Turns a vague idea into a clear, evaluated problem statement before any spec or code. Use when a request is a one-liner, the problem is fuzzy, you're choosing between directions, or you're not yet sure the idea is worth building.

Handles production incidents — mitigate first, diagnose second, learn blamelessly after. Use when something is broken in production, an alert is firing, users are impacted, coordinating response, or running a postmortem.

Builds in small, verified increments instead of one big batch. Use when implementing any feature or change — slice vertically, prove each step works, commit at green, then move to the next.

Designs clear, stable contracts for APIs, modules, events, and library boundaries. Use when adding or changing an endpoint, public function, schema, config, or any surface other code or teams depend on.

Verifies a change is truly ready to ship — rollout plan, monitoring, rollback, and communication. Use before deploying or releasing to production, cutting a release, or expanding rollout to more users.

Builds reliable product features on top of LLMs — prompts, tools, evals, and guardrails. Use when adding AI/LLM functionality, designing prompts or agent tools, fixing flaky model behavior, or shipping and maintaining a model-powered feature in production.

Builds and nurtures user community — welcome flows, discussions, feedback loops, events, and retention. Use when you need users to engage on your page, stick around, refer others, or when launching in Discord, forums, or product communities.

Creates long-form marketing content that educates and converts — blog posts, tutorials, newsletters, case studies, and landing copy. Use when you need articles, guides, launch posts, or email content that drives developer engagement and sign-ups.

Designs email sequences that onboard, educate, and retain users — welcome series, drip campaigns, and re-engagement. Use when sign-ups don't activate, users go quiet, or you need automated nurture beyond social posts.

Builds a go-to-market plan for a product — positioning, ICP, channel mix, messaging, and campaign calendar. Use when launching a product, planning marketing, choosing channels, or aligning the growth team on what to say and where.