Find and eliminate N+1 database access where one query per row replaces one query for the set, using eager loading, batching, or a dataloader.
Summarise and cross-tabulate large tables quickly with pivots, keeping the source data clean and the refresh reliable. Use when aggregating data by category, period, or dimension.
Write openings that earn the next sentence: hook the reader, promise value, and get to the point fast. Use when a piece's beginning is slow, generic, or buries what matters.
Hold a consistent standard across everything a company ships, with agents that review against written criteria and escalate disagreements rather than averaging them.
Design builds that are fast, reproducible, and cacheable, so developers wait less and CI costs less. Use when builds are slow, flaky, or produce different results locally and in…
Instrument mobile apps for crash-free rate, ANR and hang detection, and release health you can gate rollouts on.
Use ARIA correctly by preferring native HTML, applying roles/states/properties only where needed, and following known widget patterns.
Decide rollback versus fix-forward, handle migrations safely, and rehearse rollbacks so they work under pressure.
Lay out VPCs, subnets, private connectivity, and DNS so services reach each other privately and the internet only on purpose.
Ship over-the-air firmware with A/B slots, signed images, power-loss resilience, and staged fleet rollout.
Configure what a coding agent may do without asking, balancing autonomy against the cost of an unwanted action. Use when setting up an agent's permissions for a project.
Choose batch size understanding its effect on gradient noise, memory, throughput, and generalisation, and adjust the learning rate with it.
Build a deck that supports a spoken argument, with one idea per slide and visuals that carry meaning. Use when presenting to an audience rather than sending a document.
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.
Reason about how running time and memory grow with input size, and know when the asymptotic answer is the wrong one.
Migrate workloads to the cloud with honest 6R triage, dependency mapping, and rehearsed cutovers with rollback.
Define what a project includes, excludes, and depends on before work starts, so scope disagreements surface early. Use when starting a project or when a project keeps growing.
Understand what happens between source and running program, so build errors, linking failures, and optimisation surprises become tractable.
Keep a retrieval corpus current as source documents change, with incremental updates, deletion propagation, and a stated staleness budget.
Produce campaigns with agents that research the audience, draft variants against a brief, check claims and brand voice, and leave publishing to a human.
Use an agent to write tests that check behaviour rather than restate the implementation, and verify they can actually fail. Use when adding coverage to existing code.
Run an org-level board that grades incident postmortems against a quality bar, promotes cross-cutting fixes to owned work, and reads across incidents for trends.
Handle refunds, chargebacks, and disputes with evidence, deadlines, and a policy applied consistently. Use when building refund flows or responding to a chargeback.
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.
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.
Direct an agent through a refactor in verifiable steps with tests as the safety net, rather than one large rewrite. Use when restructuring code with agent assistance.
Organize Go packages by domain with internal boundaries, consumer-side interfaces, and structure that grows on demand.
Write replies that answer the question, respect the customer's time, and avoid the phrases that make people angrier. Use when writing any customer-facing support message.
Improve LCP, CLS, and INP by measuring field data, tracing each metric to its specific cause, and applying the fixes known to move that number.
Use CTEs to name intermediate steps so a complex query reads as a sequence rather than a nest, and know when they cost performance.
Triage lint rules so bug-catchers are errors, style is left to the formatter, and every suppression carries a reason.
Cut the CPU and bytes spent turning objects into wire or disk format by choosing the right format, reusing schemas and buffers, and avoiding copies.
Decide per operation what happens during a network partition, and design degraded modes that fail safe. Use when planning multi-node or multi-region behavior under network failure.
Track every commitment from assignment to completion, chasing what is late and escalating what is stuck, so work finishes rather than fading.
Give agents context in stages, escalating to more capable models or fuller context only when the cheap path proves insufficient.
Write tutorials that take a learner from zero to a working result through tested steps with checkpoints and recovery.
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.
Run the daily operating rhythm with agents that sweep every system each morning, surface what needs a decision, and keep nothing waiting silently.
Use JSON Web Tokens safely by pinning the algorithm, keeping lifetimes short, and pairing them with a revocation path.
Choose between pulling changes on a schedule and receiving pushed events, based on latency needs, reliability, and control.
Build landing pages with a clear message hierarchy, credible proof, and one decisive call to action, tested where it matters.
Run a product-engineering squad of agents from spec to shipped change with a PM, an architect, two engineers, a reviewer, and QA.
Choose between local stdio and remote HTTP transports for an MCP server based on trust, deployment, and who runs it. Use when deciding how a server will be hosted and reached.
Understand what attention computes and why its cost grows quadratically with sequence length, to reason about context limits and efficiency work.
Choose a compression codec and level by weighing size reduction against CPU cost, and place compression where the bytes are actually scarce.
Build dashboards that answer specific questions at a glance, rather than displaying every available metric. Use when a team needs shared visibility into an ongoing situation.
Decide where functions-as-a-service fit using cold-start, limit, and cost-crossover math. Use when choosing between serverless and containers, or rescuing a serverless design that…
Defer expensive work until the moment it is actually needed, so startup stays fast and unused paths cost nothing.
Size worker pools, queue depths, and batch widths against the real bottleneck so parallelism adds throughput instead of contention.
Order material so each piece is learnable when it arrives, with prerequisites satisfied and difficulty increasing gradually.
Grow engineers through goal-anchored mentoring, calibrated stretch work, and questions before answers. Use when mentoring individuals or building a team's growth practice.
Decide whether to refactor code in place or rewrite it from scratch using risk math, not frustration. Use when a component feels beyond repair and someone proposes starting over.
Run repeatable delivery reliably by finding the constraint, reducing variability, and measuring flow rather than utilisation.
Verify a provider against its consumers' recorded pacts in CI so a breaking API change fails before it ships.
Decide between managed services and self-hosting with honest TCO, lock-in assessment, and exit paths.
Choose between active-passive and active-active multi-region architectures with eyes open to data, cost, and failover reality.
Write engineering resumes with quantified impact bullets, honest tailoring, and machine-readable formatting. Use when writing or reviewing a technical resume.
Place labeled, greppable print statements at decision points to trace the real execution, then remove them cleanly.
Express organisational rules as automated checks in the pipeline rather than as documents people are meant to follow.
Direct and supervise a coding agent (Claude Code, Cursor, Antigravity) so it ships correct, verified work.