Reshape rows into columns and back, and know when the reshape belongs in SQL rather than in the reporting layer.
Choose batch or streaming from honest latency requirements and operate the complexity you actually need.
Run release agents that draft the changelog, scan risk, verify the candidate, and gate publish behind a go/no-go check.
Match storage class to access pattern so rarely read media costs less without becoming unavailable. Use when media storage cost grows faster than usage.
Run alert triage as agents that dedup the storm, rate severity by user impact, match a runbook, and draw a hard human-escalation line.
Understand what the kernel does for your process, so system-level behaviour such as scheduling, file descriptors, and signals stops being mysterious.
Run a publishing cadence with agents that plan a calendar, research and draft against a brief, fact-check claims, and queue posts for human approval.
Plan GPU spend by comparing owned hardware, reserved cloud, and on-demand against real utilization and lead time, so you commit at the right break-even.
Load web fonts without layout shift by subsetting the file, setting font-display, preloading first-paint weights, and matching fallback metrics.
Answer questions that need several linked lookups by decomposing the query and retrieving in sequence.
Provide filters that narrow results honestly, with counts that reflect what is actually available and a clear way back out.
Keep a repository free of stale branches, dead files, oversized objects, and abandoned configuration. Use when a repository has grown cluttered or slow to clone.
Operate as a solutions architect who turns a customer's constraints into a defensible reference design and a path to production.
Organize documentation with the Diataxis four-quadrant model, navigable structure, and searchability. Use when structuring a docs site or when readers cannot find what they need.
Give agents context in stages, escalating to more capable models or fuller context only when the cheap path proves insufficient.
Use present value, rate, and payment functions correctly, with consistent periods and sign conventions. Use when modelling loans, investments, or discounted cash flows.
Convene several reviewer agents with fixed distinct lenses, correctness, security, cost, and simplicity, then synthesize their verdicts into one.
Write engineering resumes with quantified impact bullets, honest tailoring, and machine-readable formatting. Use when writing or reviewing a technical resume.
Structure cloud IAM with role-based access, short-lived credentials, and permission boundaries that hold at scale.
Fit and interpret regression models for insight, reading coefficients, fit, and caveats honestly rather than as causal truth.
Write onboarding docs that get a new contributor to a verified working setup and a first contribution fast.
Give feedback that improves performance, timed and framed so it is used rather than defended against. Use when coaching, reviewing work, or mentoring.
Insert or update in one statement without races or lost updates, using the engine's conflict handling rather than check-then-write.
Coordinate multi-service transactions as a sequence of local steps with compensations, timeouts, and an observable state machine.
Write bash that fails loudly, quotes correctly, cleans up after itself, and passes shellcheck. Use when writing shell scripts that automation or other people will depend on.
Build a modular monolith with clean internal seams and split to services only on proven pressure. Use when starting a system or resisting premature microservice decomposition.
Design SDKs that feel idiomatic per language, handle auth and resilience, and version cleanly. Use when building an official client library for your API.
Decide what to hand to an agent, what to keep with a human, and what to split, based on reversibility and consequence rather than capability alone.
Apply complexity analysis where input size actually makes it decide performance, and ignore it where constant factors dominate.
Apply normal forms pragmatically and denormalize deliberately, weighing update anomalies against read performance.
Handle Unicode end to end so text survives storage, transport, and display without mojibake or truncation mid-character.
Paginate large result sets so page cost stays constant by using keyset (cursor) pagination instead of OFFSET, with a stable, encoded cursor.
Produce invoices and receipts that are accurate, immutable, and contain what tax authorities and customers require.
Deploy an LLM on vLLM with continuous batching, deliberate VRAM planning, and multi-model hosting that never overcommits the card.
Interpret what a user meant before matching, through normalisation, intent detection, and entity extraction.
Operate as a DevOps engineer who owns the delivery pipeline, keeps environments identical, and makes every deploy reversible.
Ship FP16, BF16, or FP8 training and inference that holds accuracy while capturing the speedup, using loss scaling and numeric validation.
Manage long agent sessions with checkpoints, context resets, and clear task boundaries so quality does not decay. Use when working with an agent over an extended piece of work.
Pursue a high-level goal to completion autonomously: lock the done-condition, decompose, execute with verification, adapt, and know when to stop.
Manage specificity with layers, :where, and low-specificity selectors so overrides stay predictable. Use when styles fight each other, !important spreads, or you are setting…
Return structured problem+json errors with stable codes, retryability signals, and correlation ids. Use when standardizing API error shapes or making failures debuggable across…
Use an agent to review a diff productively, with the right scope, framing, and scepticism about its findings. Use when reviewing your own changes before requesting human review.
Hand off an on-call rotation by transferring open incidents, watch items, and the tribal context runbooks miss.
Wire a static analysis scanner into CI so it blocks real security bugs while staying under a defined noise budget.
Work with an agent on a bug by supplying evidence and letting it form hypotheses, rather than asking it to guess from a description. Use when debugging with an agent's help.
Remove embedded metadata such as location, device, and author from user files before they are stored or shared. Use when users upload photographs or documents that others will see.
Prepare for and perform in technical interviews with a practice system, aloud reasoning, and honest calibration. Use when preparing for coding, system design, or behavioral rounds.
Configure automated dependency and vulnerability scanning at a cadence people will actually act on. Use when dependencies drift or vulnerabilities go unnoticed.
Turn a rough draft into finished writing through structured revision passes: cut, clarify, then polish. Use when improving your own or others' writing after the first draft exists.
Validate every redirect destination against a server-side allowlist so a user-controlled target cannot bounce victims onto an attacker's site.
Let teams provision what they need within guardrails, without waiting for an infrastructure team to act. Use when provisioning requests queue and infrastructure work is reactive.
Cut LLM cost and latency with caching, model tiering, prompt diet, batching, and streaming UX. Use when the inference bill or response time needs engineering down.
Work with the borrow checker through ownership-first design instead of fighting it with clones and unsafe.
Improve output through repeated critique and revision against a fixed standard, stopping when the standard is met or gains stop.
Control the clock in tests through an injectable time source so "now" is frozen and timezone behavior is explicit.
Run competitive analysis as agents that tear down assigned competitors on one template, enforce sourcing rules, and synthesize implications for your product.
Run write-first collaboration with the right document types, response-time norms, and meetings reserved for what writing cannot do.
Design autoscaling on the right metric with velocity controls, warm capacity, and flap prevention. Use when configuring autoscaling or diagnosing oscillation, lag, and cost spikes…
Draw system, sequence, and flow diagrams that clarify rather than decorate, at a consistent level of abstraction. Use when explaining a system to people who did not build it.
Present results so a user can judge relevance without opening each one, with useful snippets, clear grouping, and honest metadata.