Ranked, opinionated, per stack

One-time setup when bringing a repo under agent-assisted work — get oriented, write its CONTEXT.md, install the skills, record deviations from AGENTS.md, seed .out-of-scope

Orchestration for a production incident — from the page through mitigation, root cause, fix, and postmortem, invoking the incident and deployment skills in order

End-to-end orchestration for building a non-trivial new feature — invoke the right skills in order, from alignment through to release

The development loop for a change that fits in roughly one session — orient if needed, pick the domain skill for the area, build test-first, deslopify, clean the commits, self-review, security-check if warranted, ship

Decide whether to add a library before adding it — API surface via Context7, architecture via DeepWiki, maintenance and CVE check, transitive cost, alternatives

A relentless interview that sharpens a plan, design, or decision before any code is written — map the open decisions as a tree, ask the whole frontier one round at a time with a recommended answer for each, look up facts yourself, stop only when nothing is left silently assumed

Compact the current session into a portable handoff document so a fresh agent (new tool, new machine, a colleague) can pick the work up

Get up to speed in an unfamiliar codebase fast — find the entry points, trace the main data flow, learn the local conventions and the landmines, then write it down as the project's CONTEXT.md

Break a multi-session plan into phases that each fit one context window — vertical tracer-bullet slices, a non-goals list per phase, a checkable definition of done, and a real rollback point (git tag or merged PR) at every boundary

A timeboxed throwaway experiment to answer one specific question — build the smallest thing that resolves the unknown, then delete the spike and write up the answer

Turn a decision you can't settle yourself into a Markdown questionnaire for the one person who holds the missing knowledge — a client, a domain expert, the exec who owns the business rules

Draft an Architecture Decision Record using Tejas's template — numbered, immutable once accepted, table header, `---` dividers, emoji H2s

Draft a PRD using Tejas's template and house conventions — table header, `---` divider between every section, emoji H2s, outlines for prose and tables for structured data

Design a REST (or RPC) endpoint before implementing — resource and verb, request/response shape, status codes, pagination, filtering, idempotency, versioning under a v1/ folder, and auth

Design the schema and semantics of a domain event before publishing it — event vs command, name, payload (thin vs fat), key, versioning, delivery guarantee, and how consumers classify failures

Design a table or collection before the migration — model the entities and relationships, pick keys and indexes for the real access patterns, decide normalization vs denormalization, name columns to match the domain and the wire layer

Change a live API, response shape, error code, or event schema without breaking consumers — classify the change as compatible or breaking, make compatible changes additively, version breaking ones, and never alter a legacy contract

Add a new feature module to an existing NestJS service following Tejas's layout — versioned `v1/` folders for controllers/services/dto, module-local `constants.ts`, `.controller.options.ts` for route metadata, entity or schema folder, snake_case at the wire/DB layer

Bootstrap a new repo or service the way Tejas's existing repos are set up — pick the closest existing template, then apply the standard baseline (house-style README, MIT LICENSE.md, commitlint conventional config, husky commit-msg/pre-commit/pre-push hooks, security-audit workflow, issue/PR templates, .nvmrc / .python-version / go.mod)

Review a DevOps / CI-CD / infra PR the way Tejas reviews — secrets exposure first, then supply-chain pinning and least-privilege, then reproducibility, Dockerfile hygiene, CI correctness, and release/versioning

Review a Go backend PR the way Tejas reviews — correctness first (concurrency safety, error handling, context propagation), then optional-dependency degradation, queue/message lifecycle, then reuse and dead-code hygiene

Review a backend PR the way Tejas reviews at Habuild — reuse-over-abstraction, prod-log discipline, config/env hygiene, Nest DI and cache correctness, and a terse blocking/non-blocking split

Review a Python backend PR the way Tejas reviews — reuse over new abstraction first (same as the Nest corpus), then logging/config/dead-code hygiene, then correctness (warnings-as-errors, no broad except, contract stability)

Review a React / Next.js frontend PR the way Tejas reviews — reuse over new component/abstraction first, then hooks and RSC correctness, then accessibility, then render performance

Find the commit that introduced a regression with git bisect — pin a known-good and known-bad commit, automate the test where possible, land on the culprit, then understand why

Break a circular dependency or an over-tight coupling — a forwardRef triad, two modules that import each other, a service reaching across a boundary it shouldn't

Repo-wide removal of code nothing calls — unused exports, unreachable branches, registered-but-never-invoked handlers, scaffolding for tech the stack doesn't run, commented-out blocks

Strip AI slop from code an agent just wrote — comments that restate the code, defensive branches for cases that can't happen, abstractions with one implementation, commented-out code, verbose docstrings on obvious functions

Split a file or module that's grown too big — find the real seams, pull out a cohesive piece with a narrow interface, move the tests with it, keep every commit green

Tidy a feature branch before it merges — squash fixup commits into their targets, drop "wip" noise, reorder so prefactors come first, rebase onto the base branch, keep history linear

Resolve merge or rebase conflicts by understanding both sides' intent, not by picking one blindly — reconstruct what each change was for, combine them, verify the result builds and both features still work

Turn a messy working tree or a fat WIP commit into a clean series of conventional commits — one logical change each, each one building and passing tests, subjects in the right type

Test-driven development — the red → green loop done so it produces tests worth keeping

The user types this when a message didn't land — re-pitch what you just said, shorter AND with the context they were missing, in plain English, using the vocabulary from the project's CONTEXT.md. "Wait" names the listener's state, not the output, so the fix is both fewer words and the missing premise, not a terse rewrite

Rename or retype something whose blast radius fans across the whole codebase — a shared column, a widely-imported symbol, an enum value — using expand → migrate in batches → contract, so CI stays green the whole way

Model and query BigQuery for analytics without burning slots or money — partitioning and clustering, always filter the partition column, avoid SELECT * (columnar billing), nested/repeated fields, streaming vs batch load, approximate aggregates, scheduled queries and materialized views, and never treat it as an OLTP store

Choose a caching strategy and keep the cache correct — cache-aside vs read/write-through, invalidation on write, negative caching done safely, stampede protection, and TTL as the backstop

Write and review MongoDB aggregation pipelines — stage order for index use ($match/$sort first), $group, $lookup and $unwind cost, $facet, memory limits and allowDiskUse, and when to use a materialized rollup instead

Model MongoDB documents for the access patterns — embed vs reference, the schema design patterns (subset, computed, bucket, outlier, extended reference), array pitfalls, index for the query shape, and the $lookup cost

Write and review Postgres aggregation queries — GROUP BY, window functions, CTEs and the materialization gotcha, FILTER, ROLLUP/GROUPING SETS, lateral joins, keyset pagination, and materialized views for expensive rollups

Choose and verify Postgres indexes for real query shapes — index type (btree / GIN / GiST / BRIN), composite column order, partial / covering / expression indexes, reading EXPLAIN ANALYZE, adding them CONCURRENTLY, and knowing when NOT to index

Use Redis for distributed locks and rate limiting correctly — single-instance SETNX+TTL with a fencing token, lock renewal, Redlock caveats, and atomic rate limiters (fixed window, sliding window, token bucket) via Lua

Use Redis correctly — client choice and connection handling, namespaced key design, TTL on everything, the right data structure per use, SCAN not KEYS, pipelines vs MULTI, and maxmemory-policy

Review a database or cache access path for correctness and cost — N+1, missing index, unbounded result set, transaction scope, and the Redis/cache-key issues from the review corpus (read key ≠ write key, KEYS on a shared instance, negative tombstones, replica lag on read-your-writes)

Build and review BullMQ (Redis-backed) job queues in Node/NestJS — queue and worker setup, concurrency, attempts and backoff, removeOnComplete/Fail, delayed and repeatable jobs, rate limiting, flows, graceful shutdown, idempotent job IDs, and the fact that Redis is the source of truth

Design and operate Kafka / Amazon MSK correctly — topic and partition design, partition key choice and hot partitions, consumer groups and rebalancing, offset commit semantics, idempotent/transactional producers, retries and dead-letter topics, schema registry, and the pain of repartitioning

Build and review an AWS SQS consumer correctly — classify every error terminal vs retryable, delete only after the downstream write succeeds, match visibility timeout to handler runtime, confirm the redrive policy and DLQ, handle partial batch failures, and make handlers idempotent

Use traces, metrics, and logs to locate a production problem — start from the symptom in Grafana, find exemplar traces in Tempo, walk the span tree to the slow or failing hop, correlate with logs by trace_id

Define alerts and SLOs that page on real user pain, not noise — pick SLIs from the RED metrics, set a target and error budget, alert on burn rate (multi-window), and make every alert actionable with a runbook link

Add tracing, metrics, and structured logs to a service using OpenTelemetry and the LGTM stack (Loki, Grafana, Tempo, Mimir) — spans on the real boundaries, RED metrics, log discipline, and the rule that observability init must degrade, never crash

Cut over from an old implementation, API version, or service to a new one without downtime — dual-run behind a feature flag, ramp traffic gradually, fall back on error, keep a kill switch, then remove the old path once the new one is proven

Cut a release the way Tejas's repos do it — derive the next semver from conventional-commit history, write grouped release notes, tag `vX.Y.Z`, and let the tag-triggered workflow build

Migrate a live database safely — additive schema changes first, backfill in batches with no long locks, expand/contract for anything that isn't purely additive, reversible, and decoupled from the code deploy

Take a change to production safely — pre-deploy checks, decouple schema/config/code steps, roll out gradually (flag / canary), watch the right signals, and know the rollback trigger before you start

Ship an urgent production fix without the full process overhead but without cutting the dangerous corners — smallest possible change, branch from the released tag, cherry-pick, expedited review, deploy with extra watching, then backport to main

Get production back to a known-good state fast and safely — flip the flag or redeploy the previous artifact, deal with migrations that can't be un-run, verify recovery, then follow up with a postmortem

Run a live production incident — declare severity, assign roles, stabilize (mitigate before fixing), communicate on a cadence, keep a timeline as you go, and hand off to a postmortem when it's resolved

Work a bug the way Tejas wants it worked — reproduce first, isolate with evidence, form one hypothesis at a time, trace the mechanism end to end before proposing a fix

Handle being on call — triage an alert (real vs noise, severity, is it actionable), respond or escalate, keep the shift log, and hand off cleanly

Write a blameless postmortem using the template — table header, timezone-stamped timeline, root cause traced end to end, owned and dated action items

Run the dependency audit for a repo's stack, triage the findings by reachability and severity, and update packages safely — lockfile regenerated, changelog noted, tests green

A dedicated security pass over a diff or a service — deeper than the PR-review checklist

Take a research paper apart section by section until it's understood — Keshav's three passes, the paper's history (the prior work it builds on and the work that followed, resolved through arXiv and Semantic Scholar, never invented), every symbol defined, every equation built intuition-first with a worked number, key figures redrawn as interactive widgets, and an honest critique

Check whether you really understand something by explaining it back — pin one concept, take a 1–5 confidence reading, explain it from memory as if to a 12-year-old, then get graded against a fixed six-gap rubric (missing causal chain, circular definition, undefined jargon, missing boundary, missing concrete example, broken analogy), one gap and one Socratic question at a time, never the answer up front

Explain a concept, algorithm, request path or codebase flow as a diagram you step through — pick the one question it answers and the diagram type that fits (flowchart, sequence, state, data-flow), keep it to 5–12 nodes grounded in real code with file:line, then build an interactive HTML page where Next/Prev highlights each step and a side panel narrates what happens there, why, and what can go wrong

Teach any topic the way the Head First books do — a concrete problem before the theory, pictures with the words in them, a conversational voice, the name of the idea given only after the reader has felt the need for it, and the books' recurring beats (Sharpen your pencil, Brain Power, There are no Dumb Questions, Fireside Chat, Bullet Points) turned into an interactive HTML lesson

Build crafted, highly detailed, interactive isometric SVG figures that explain a technical idea as a real physical object (a test rig, a dial gauge, a cabinet of drawers, a plotter, a lock), with many small precise solid parts, four-tone shading, correct painter's order, a framed card with title, hint and live readout, and calm eased motion

Turn an English description (or Mermaid source) into a diagram you can keep editing — the `.mmd` source, crisp SVG and PNG rendered with the Mermaid CLI, and an editable `.excalidraw` scene

Applies motion design principles to create emotionally-driven, technically sound animations and transitions

Periodically check the workbench skills for rot — dead cross-links, references to files/flags/tools that no longer exist, stale tooling assumptions, missing frontmatter, drift between a skill and the conventions it cites, and category READMEs out of sync

Build (or extend) a PR-review skill from a real corpus of the reviewer's own comments — pull them with `gh`, analyse what they flag, what they let slide, and how they phrase it, then emit a skill file in the house format

Author a new skill for this repo in the house style — YAML frontmatter with a trigger-rich description, terse mechanism-focused body, a "what to let slide" section for review skills, an anti-patterns list, grounded in real conventions not generic advice