Issue, install, renew, and debug TLS certificates so connections stay encrypted and trusted without surprise expiry.
Redistribute work across desks and workers as load shifts, so one bottleneck does not stall the company while others idle.
Configure automated dependency and vulnerability scanning at a cadence people will actually act on. Use when dependencies drift or vulnerabilities go unnoticed.
Ship mobile releases through phased rollouts with hotfix paths and a forced-upgrade policy that never strands users.
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.
Classify API changes as breaking or compatible, evolve additively, and gate breaking changes with compatibility tests.
Deliver webhooks with signatures, retries, and ordering rules consumers can actually build against. Use when adding webhooks to a product or hardening delivery and verification on…
Fuzz a parser or protocol handler with a coverage-guided fuzzer, seed the corpus with real inputs, and triage crashes to unique root causes.
Use server-initiated model calls and user prompts responsibly, so a server can ask for reasoning or input without seizing control.
Collect and keep only the personal data a feature actually needs, so exposure, cost, and compliance burden all shrink at once.
Version and share seed datasets so they stay small, realistic, and reproducible across a team. Use when tests or local environments depend on fixture data that is drifting,…
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.
Assign a role to shape expertise, register, and priorities, without pretending it grants knowledge the model lacks.
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.
Scale databases by partitioning and sharding with a good key, handling resharding and cross-shard queries, and knowing when to avoid it.
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.
Replace a hot algorithm with one of better complexity, a fitter data structure, or memoized results instead of micro-tuning the slow one.
Grow engineers through goal-anchored mentoring, calibrated stretch work, and questions before answers. Use when mentoring individuals or building a team's growth practice.
Instrument LLM applications with request tracing, token accounting, quality signals, and feedback loops.
Choose the weakest consistency model each use case tolerates, from linearizable to eventual. Use when designing replicated data paths or explaining anomalies users report as bugs.
Run an architecture board of agents where one proposes a design, several review it independently and blind, and a chair synthesizes a binding decision.
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.
Cut garbage-collection pauses and overhead by lowering allocation rate, sizing the heap, and reading pause logs before touching a flag.
Tune LLM serving to hold latency SLOs while raising GPU throughput, working the batch scheduler, KV cache, and paged attention together.
Ask for push permission at a moment when the value is obvious, and handle denial gracefully, because the prompt only comes once. Use when adding push to a mobile or web product.
Virtualize long lists so only visible rows mount, with correct handling of dynamic heights and scroll anchoring.
Get matrix multiplies onto the tensor cores by fixing shapes, precision, and alignment, then measure that the cores actually fired.
Store user files in object storage with presigned transfers, validation, and lifecycle rules. Use when building upload/download features or moving file handling off application…
Decide between managed services and self-hosting with honest TCO, lock-in assessment, and exit paths.
Write scripts whose reruns are always safe through check-then-act steps, atomic writes, and dry-run modes. Use when automation may run twice, die halfway, or need a safe retry.
Build landing pages with a clear message hierarchy, credible proof, and one decisive call to action, tested where it matters.
Fit firmware into kilobytes with static allocation, measured stack sizing, and linker-map budgeting. Use when developing on microcontrollers or debugging overflows and…
Stay within a provider's limits and respond correctly when you exceed them, without hammering or stalling. Use when calling any API at volume.
Split a large task across parallel agents that each handle one slice, then merge their outputs deliberately.
Apply optimistic updates with correct rollback, conflict handling, and pending cues so mutations feel instant without lying.
Produce preview images for files of every type, consistently sized and generated without blocking the user. Use when a file list or gallery needs visual previews.
Support claims with specifics, data, and examples so writing is credible and concrete instead of vague assertion.
Break a project into milestones that each prove something, so progress is verifiable rather than asserted.
Write a north-star architecture document that sequences migrations and guides decisions without pretending to be a roadmap.
Match storage class to access pattern so rarely read media costs less without becoming unavailable. Use when media storage cost grows faster than usage.
Aggregate desk-level state into an honest company view where problems stay visible instead of averaging away.
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.
Operate as a product data scientist who frames falsifiable hypotheses, analyzes experiments, and reports results without flattering the launch.
Read a stack trace to find the cause frame instead of stopping at the symptom on top. Use when an exception, panic, or error dump lands and you need to locate the line that is…
Choose embedding models and chunking by evaluating retrieval on your own corpus, not by leaderboard rank.
Learn something substantial without a course, by defining the goal, finding the right resources, and building feedback into the process.
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.
Find the code that actually burns CPU time using a sampling profiler and a flame graph instead of guesswork.
Assign log levels deliberately so error wakes a human, warn flags a trend, and info and debug explain later without burying the signal.
Run a JavaScript/TypeScript monorepo with workspaces, task orchestration, and internal package versioning that scales.
Run a performance calibration meeting so ratings across a group rest on comparable evidence and a consistent bar, not one manager's advocacy.
Reason about rounding, precision limits, and comparison in floating point so numerical results are predictable.
Work with immutable data in JavaScript through structural updates, readonly types, and freeze where it earns its cost.
Store, scope, and rotate integration credentials so a leak is survivable and rotation does not cause an outage. Use when managing keys for external services.
Run a team of documentation agents that finds the gaps, drafts the pages, gets them reviewed against the code, and sweeps for staleness on a schedule.
Choose and size a JVM garbage collector from latency goals and allocation behavior, and read GC logs before tuning flags.
Find and remove duplicate rows deterministically, keeping the record you meant to keep. Use when a table has accumulated duplicates or an import needs a clean unique set.
Treat tool output as untrusted data, confirm destructive actions, and keep an agent's reach inside what its user may do.
Coordinate multi-service transactions as a sequence of local steps with compensations, timeouts, and an observable state machine.