Judge a canary release against a concurrent baseline using pre-set metric gates, automatic rollback, and statistically honest windows.
Handle operations that touch several services where some succeed and some fail, without leaving inconsistent state. Use when a single user action calls multiple systems.
Give feedback that improves performance, timed and framed so it is used rather than defended against. Use when coaching, reviewing work, or mentoring.
Run an agent across several MCP servers without name collisions, tool overload, or ambiguity about which server owns an action.
Profile GPU work with Nsight Systems and Nsight Compute to read the timeline, name the bottleneck class, and pull the metric that dictates the fix.
Audit unsafe blocks by verifying documented invariants, minimizing surface, and testing under sanitizers and Miri.
NVIDIA TensorRT model optimization and deployment. Convert models to TensorRT engines, configure optimization profiles and precision modes, apply INT8 calibration, analyze kernel…
Organize writing so the reader is carried from point to point without friction: logical order, transitions, and signposting.
Set timeout budgets per hop and retry policies that cannot amplify an outage, with circuit breakers where they pay.
Turn raw sensor readings into trustworthy data with correct sampling, filtering, calibration, and timestamped batching.
Write so the reader understands on the first pass: plain words, concrete nouns, one idea per sentence.
Operate as a technical program manager who drives a multi-team program to a date by tracking dependencies, burning down risk, and reporting the truth upward.
Assemble an investor or board update from source metrics with agents that draft, fact-check every number, and surface bad news rather than bury it.
Present results so a user can judge relevance without opening each one, with useful snippets, clear grouping, and honest metadata.
Design backups around tested restores, point-in-time recovery, and backup security. Use when setting up database backups or verifying that existing backups would actually work in…
Audit third-party packages by pinning resolved versions, scanning against advisory databases, and catching malicious lookalikes before install.
Drive a real debugger with breakpoints, watch expressions, and conditional stops to read live program state at the moment of failure.
Run a game day that injects a real failure on purpose under safety rails, then captures what monitoring, runbooks, and responders actually did.
Keep a long training job alive across GPU failures, node evictions, and stragglers so one bad host costs minutes, not the whole run.
Run a team of support agents that triages each ticket, reproduces the problem, drafts a reply, and hands clean escalations to a human.
Structure issues, labels, and boards so the tracker reflects reality and answers what is being worked on. Use when the backlog has grown beyond what anyone reads.
Match storage class to access pattern so rarely read media costs less without becoming unavailable. Use when media storage cost grows faster than usage.
Choose and write the right join so rows are neither lost nor multiplied, and know why a result set grew. Use when combining tables and the row count or the null columns look wrong.
Choose an optimiser and its hyperparameters based on the problem rather than habit, and know what each actually does.
Replace a hot algorithm with one of better complexity, a fitter data structure, or memoized results instead of micro-tuning the slow one.
Debug by turning a belief about the code into a falsifiable hypothesis, predicting an observable, and running the one probe that can refute it.
Know where personal data physically goes and keep transfers lawful when it crosses a border. Use when choosing a region, adding a vendor, or designing replication and backups.
Coalesce a flood of small operations into fewer larger ones with batch windows, debounce, or throttle, chosen by whether you need the last event or a steady rate.
Configure rules that stop unreviewed or broken code reaching the default branch, without making routine work impossible.
Catch fencepost bugs by writing down the boundary convention and testing the endpoints instead of the middle.
Produce signed software bills of materials from real artifacts and consume them to answer "are we affected" fast.
Reason about how model performance improves with parameters, data, and compute, to allocate a training budget sensibly.
Navigate ESM and CommonJS, interop between them, and structure imports so bundlers can tree-shake. Use when hitting module-resolution errors, mixing ESM and CJS, or shrinking a…
Move between API versions or providers without downtime, using parallel running and staged cutover. Use when a provider deprecates a version or you are replacing a service.
Build disaster recovery around RTO/RPO tiers, verified backups, and drills that prove the numbers. Use when writing a DR plan or testing whether the existing one actually works.
Keep a project alive without burning out its maintainers, through scope limits, shared load, and honest signals about capacity.
Understand unfamiliar code quickly by tracing real execution paths rather than reading files in order.
Run a team of growth agents that designs an experiment, builds the variant, analyzes the result, and passes an ethics gate before anything ships.
Store passwords with a slow, salted, memory-hard hash and a plan to raise the cost over time. Use when building signup or login, migrating off a weak hash, or reviewing how a…
Build small, fast, secure container images with layer caching, multi-stage builds, and a minimal base policy. Use when images are bloated, slow to build, or failing security scans.
Keep tool results small enough that an agent can hold what matters, through pagination, projection, and summarisation at the server. Use when tool output floods the context window.
Reconstruct what happened from the artifacts a dead incident left behind: logs, metrics, dumps, and a timeline, when there is no live system left to poke.
Design a text search feature with the right analyzer, fields, and matching model so results are relevant rather than merely returned.
Instrument LLM applications with request tracing, token accounting, quality signals, and feedback loops.
Flatten nested conditionals into early returns that handle edge cases up front and keep the main path unindented. Use when logic marches rightward into deep nesting.
Run a data team as agents that build the pipeline, gate on quality checks, run the analysis, and independently audit every headline metric.
Aggregate desk-level state into an honest company view where problems stay visible instead of averaging away.
Write status updates with progress, risk, and asks calibrated to the audience, honoring the no-surprises rule.
Get output in exactly the structure downstream code expects, using schemas, examples, and validation rather than hope.
Run a production readiness review that checks SLOs, runbooks, capacity, and dependencies before an on-call team agrees to own a service.
Validate every redirect destination against a server-side allowlist so a user-controlled target cannot bounce victims onto an attacker's site.
Profile native code with perf and flamegraphs, then read cache, syscall, and allocation behavior to find the real bottleneck.
Fuzz a parser or protocol handler with a coverage-guided fuzzer, seed the corpus with real inputs, and triage crashes to unique root causes.
Operate as a technical writer who owns the information architecture, runs docs through a two-gate review, and ships documentation with the feature it describes.
Tie every claim in a generated answer to the retrieved passage that supports it, so users can verify and unsupported claims are visible.
Understand what Raft and Paxos actually provide, quorum arithmetic, and when you need consensus at all.
Apply optimistic updates with correct rollback, conflict handling, and pending cues so mutations feel instant without lying.
Build API clients with retries, timeouts, pagination, and error surfacing baked in, and test them properly. Use when writing a client for an external or internal API.
Interpret what a user meant before matching, through normalisation, intent detection, and entity extraction.
Write unit tests that document behavior through explicit arrange-act-assert phases and a single assertion of intent.