Run attacker and defender agents in a fix-and-re-attack loop so exploitable bugs get found, triaged, fixed, and verified before ship.
Keep and present document history so users can see what changed, who changed it, and restore safely. Use when edits are shared or when accidental loss must be recoverable.
Run translation as a pipeline with catalogs, context, review, and continuous updates rather than a one-off handoff.
Extract text and structure from PDFs, office documents, and scans reliably enough to search, index, or summarise.
Find the code that actually burns CPU time using a sampling profiler and a flame graph instead of guesswork.
Observe external dependencies so their degradation is visible before users report it and attributable when it happens. Use when your service depends on APIs you do not control.
Configure tsconfig.json deliberately: the flags that matter, module and target settings, and build vs typecheck configs.
Model warehouse tables with explicit grain, conformed dimensions, and deliberate SCD handling. Use when designing analytics schemas or fixing double-counted metrics and unjoinable…
Format code on the current branch using Biome. Use when asked to format, lint, or clean up code before committing or creating a PR.
Combine diverse models through averaging, blending, and stacking to beat any single model. Use when squeezing maximum accuracy from a competition or high-stakes prediction, after…
Operate as a release manager who runs release trains, enforces cut criteria, and holds rollback authority.
Assert hard-to-specify output by reviewing a human-readable snapshot once, approving it, then failing on any later diff.
Research, qualify, and prepare partnership approaches with agents, leaving the relationship and the commitment to a human.
Record decisions with their context and predictions to enable honest calibration and defeat hindsight bias. Use when making consequential decisions you want to learn from later.
Design multi-turn conversational systems with state tracking, memory injection, topic handling, and repair.
Rebalance a top-heavy test suite toward fast unit tests without dropping the coverage the slow tests provide.
Idiomatic Rust error handling design for libraries and applications: thiserror vs anyhow boundary decisions, error hierarchy design, context chain propagation, HTTP handler error…
Produce a short honest briefing across every desk on a fixed cadence, surfacing decisions needed rather than activity performed.
Structure an email so a skimming reader gets the point, the context, and the ask in the right order. Use when an email has more than a line or two and the layout decides whether…
Pair a product-manager agent with engineer agents through spec, pushback, scope negotiation, and acceptance so the build matches intent.
Answer a request for a copy of someone's data completely, on time, and without exposing anyone else. Use when building an export path or responding to an access request.
Validate requests at the boundary with schemas, reject unknown fields, and return errors clients can act on.
Initialise parameters so signal and gradients propagate at usable scale from the first step. Use when a deep network fails to train from the start or diverges immediately.
Get the tone of an email right: warm, professional, and matched to the reader and situation, without the coldness email invites.
Run write-first collaboration with the right document types, response-time norms, and meetings reserved for what writing cannot do.
Catch timing-dependent bugs that vanish under observation by amplifying the race and moving logging off the critical path.
Design each handoff between two agents as an explicit artifact contract with a context budget and a rule for what must survive the crossing.
Treat documentation like code: in the repo, in pull requests, CI-checked, with preview builds. Use when docs drift from reality or the docs workflow is separate from the code…
Make payment operations safe to retry so a network timeout never charges a customer twice. Use when calling a payment API, processing webhooks, or building any money-moving…
Run red-green-refactor honestly with the smallest failing test first, refusing test-after backfill dressed up as TDD.
Understand the layers between a request and its response, so latency, connection failures, and timeouts can be attributed to the right layer.
Write the docs that decide whether someone adopts a project: a truthful readme, a working quickstart, and answers to the first questions.
Prepare documents for physical printing with correct colour, bleed, resolution, and fonts, so what prints matches what you designed.
Profile JVM services with async-profiler and JFR, separating CPU, allocation, and lock evidence, safely in production.
Build reusable reply templates that speed common answers without making replies feel automated. Use when agents retype the same explanations daily.
Let clients work disconnected and reconcile changes on reconnect without losing edits or resurrecting deletions.
Establish heuristic and simple-model baselines that bound what complexity is worth. Use when starting any ML project or auditing whether a complex model earns its cost.
Make immutability the default so aliasing bugs turn into compile errors or no-ops instead of action at a distance.
Apply happens-before reasoning, volatile, and safe publication to write correct concurrent Java/Kotlin.
Deploy an LLM on vLLM with continuous batching, deliberate VRAM planning, and multi-model hosting that never overcommits the card.
Handle plurals, grammatical gender, and agreement using locale plural categories rather than an if-else on count.
Prepare, run, and close meetings with agents so each one produces decisions and owned actions instead of discussion.
Pick an assertion style and write checks that fail with a message you can diagnose without a debugger.
Produce API reference docs that blend generation with curation, an example per endpoint, and documented errors.
Make switch and match statements provably total so adding a case forces every site to handle it, with no default that hides the gap.
Run a team of postmortem agents that builds the timeline, analyzes causes, drafts corrective actions, and reviews for blamelessness and completeness.
Build data pipelines that rerun safely, backfill cleanly, and tolerate late data. Use when designing batch or streaming pipelines or fixing ones that need manual babysitting.
Report progress in a form that surfaces problems early and lets a reader act, rather than reassuring. Use when reporting to sponsors or across teams.
Cut garbage-collection pauses and overhead by lowering allocation rate, sizing the heap, and reading pause logs before touching a flag.
Change untested legacy code safely using characterization tests, seams, and the sprout method. Use when you must modify code that has no tests and you cannot prove your change is…
Control the clock in tests through an injectable time source so "now" is frozen and timezone behavior is explicit.
Handle new requests mid-project by making the trade-off visible rather than absorbing them silently. Use when a project is accumulating additions and the date is not moving.
Instrument search so queries, clicks, and abandonment tell you what to fix. Use when improving relevance without evidence, or when nobody can say whether search works.
Operate as a CTO-level advisor who turns business goals into build-or-buy calls, org design, technology bets, and a named risk posture.
Choose isolation levels by the anomalies they prevent, understand locking versus MVCC, and retry on serialization failures.
Treat tool output as untrusted data, confirm destructive actions, and keep an agent's reach inside what its user may do.
Shape pull requests a reviewer can actually hold in their head, through small size, a why-first description, and a self-review pass.
Improve ranking with a judged evaluation set and measured changes rather than intuition. Use when search feels wrong and every proposed fix is someone's opinion.
Add redundancy where it removes a single point of failure, understanding what each level protects against and what it costs. Use when designing for availability targets.
Write a Google-style design doc that argues a decision through context, goals, and rejected alternatives before code is written.