registry

Create, critique, and operationalize engineering strategy documents using diagnosis, tradeoff exploration, guiding policy, coherent actions, and operating cadence. Use when an engineering leader needs strategy for a team, platform, architecture, migration, reliability program, or multi-quarter technical investment.

Run engineering leadership reviews across strategy, delivery, quality, architecture, launch readiness, security risk, and performance health.

Inspect GitHub pull requests for leadership-relevant release risk, quality gates, ownership, and follow-up actions.

Keep dependencies secure, minimal, and up to date. Use when auditing a project's supply chain, adding new libraries, evaluating upgrades, or hardening a CI pipeline against dependency risks.

Design and implement GraphQL APIs with correct schema design, resolver patterns, N+1 prevention, federation, and security. Use when building or evolving a GraphQL layer.

Make ML experiments reproducible and comparable by tracking hyperparameters, metrics, artifacts, and environments. Use when training models, tuning hyperparameters, or promoting models to production.

Ramp up quickly on an unfamiliar codebase by reading strategically, mapping invariants, and making safe first changes. Use when joining a project, reviewing a legacy system, or orienting in a large monorepo.

Write idiomatic, correct Rust using ownership, lifetimes, trait design, async patterns, and safe abstractions over unsafe code. Use when building Rust libraries, services, or systems code.

Verify API correctness through contract tests, integration tests, and schema validation. Use when building or consuming REST or GraphQL APIs, or when integrating services that must agree on a shared interface.

Build, configure, and operate containerized workloads with Docker and Kubernetes. Use when creating Dockerfiles, writing Kubernetes manifests, or debugging container runtime issues.

Design and build data pipelines, ETL workflows, and streaming systems. Use when ingesting, transforming, or delivering data at scale.

Design and implement event-driven systems using message queues, event streams, and async patterns. Use when decoupling services, building reactive systems, or processing high-throughput data streams.

Provision and manage cloud infrastructure with Terraform, Pulumi, or similar IaC tools. Use when writing infrastructure definitions, planning changes, or managing state safely.

Design and run load, stress, and soak tests to validate system performance under realistic and peak traffic. Use before major releases, after architecture changes, or when setting SLOs.

Build production-quality mobile applications for iOS and Android using React Native or Flutter. Use when writing mobile UI, handling platform permissions, managing offline state, or optimizing app performance.

Write clear, accurate, and maintainable developer documentation — API references, tutorials, guides, and changelogs. Use when documenting APIs, onboarding new contributors, or creating user-facing technical content.

Review and remediate web accessibility issues against WCAG 2.2 AA. Use when building UI components, reviewing HTML, or preparing for an accessibility audit.

Build AI-powered features with disciplined prompt engineering, evaluation, and observability. Use when integrating LLMs, building agents, or shipping AI capabilities.

Design, evolve, and migrate database schemas safely. Use when creating tables, changing columns, writing migrations, or reviewing data model changes.

Manage monorepos efficiently with consistent build tooling, scoped changes, and dependency hygiene. Use when working in or setting up a monorepo with multiple packages or applications.

Instrument code with structured logs, metrics, and distributed traces. Use when adding observability to services, debugging production issues, or setting up monitoring.

Write type-safe TypeScript using strict settings, precise types, and disciplined migration patterns. Use when writing TS, reviewing types, or migrating from JavaScript.

Design APIs and module boundaries with explicit contracts, compatibility rules, and error semantics. Use for public interfaces and service boundaries.

Use browser and DevTools evidence to verify frontend behavior, inspect runtime state, console logs, network traces, and performance.

Design and debug CI/CD pipelines, automation, deployment safety, and repeatable release workflows. Use for build and deployment automation.

Review code across correctness, maintainability, tests, security, and user-visible behavior. Use before merge or when assessing a change.

Reduce complexity while preserving behavior. Use when working code has become hard to read, risky to change, or over-engineered.

Load and preserve the right project context at the right time. Use when starting sessions, switching tasks, or improving agent output quality.

Reproduce, localize, reduce, fix, and guard against failures. Use when tests fail, builds break, or behavior is unexpected.

Plan migrations and deprecations with compatibility windows, rollout steps, communication, and cleanup. Use when retiring APIs or moving systems.

Create and maintain useful documentation, public API notes, and architecture decision records. Use when decisions or APIs need durable context.

Apply adversarial review to important implementation decisions before they become expensive mistakes. Use for production, security, or unfamiliar changes.

Build user-facing interfaces with strong component architecture, responsive design, accessibility, and visual polish. Use for frontend UI work.

Use atomic commits, trunk-based development, branch hygiene, and versioning practices. Use when making or shipping code changes.

Refine rough ideas into concrete proposals through divergent and convergent thinking. Use when a concept needs product or technical shaping.

Implement changes in thin vertical slices with tests, verification, and rollback-friendly checkpoints. Use for multi-file or risky changes.

Interview a user one question at a time to clarify ambiguous requests before implementation. Use when a goal is underspecified or high stakes.

Measure and improve performance using evidence, profiling, Core Web Vitals, and regression checks. Use when performance matters or regresses.

Break specs into small, verifiable tasks with acceptance criteria and dependency ordering. Use before multi-step implementation work.

Review and harden code for auth, secrets, dependencies, input boundaries, and common application security risks.