Explains hybrid search in Qdrant. Use when someone asks 'how do I setup hybrid search?', 'how to combine keyword and semantic search?', 'sparse plus dense vectors?', 'missing…
Use when Go concurrency with goroutines, channels, and sync patterns. Use when writing concurrent Go code.
Expert skill for implementing language-level concurrency support including threads, channels, and synchronization
Use when modifying existing files, refactoring, improving code quality, or touching legacy code by applying the Boy Scout Rule to leave code better than you found it.
Expert skill for designing and implementing high-quality compiler error messages
Prepare and conduct a negotiation around interests and alternatives rather than positions, so agreements are better and hold.
Pursue a high-level goal to completion autonomously: lock the done-condition, decompose, execute with verification, adapt, and know when to stop.
Pin every fixed bug with a test that fails before the fix and passes after, kept beside the code it guards.
Export a trained model to ONNX that runs portably across runtimes, closing operator gaps and proving numeric parity against the source framework.
Reach developers through docs, honest content, and community trust instead of ads they ignore. Use when marketing developer tools or building a devrel content engine.
Handle Unicode end to end so text survives storage, transport, and display without mojibake or truncation mid-character.
Match work to the agent or person best able to finish it, with explicit capacity limits so nothing is assigned into an already full queue.
Test an MCP server for protocol conformance, tool selection accuracy, and behaviour under real model calls rather than only unit tests.
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.
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.
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.
Design the empty, loading, error, and edge states that most designs skip but users constantly hit. Use when designing any screen that can be empty, loading, or fail, which is…
Convene several reviewer agents with fixed distinct lenses, correctness, security, cost, and simplicity, then synthesize their verdicts into one.
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.
Enforce authorization so access is denied by default and every request re-checks that the caller owns the specific resource, closing IDOR gaps.
Manage agent sessions including initialization, handoffs, revival (seance), and persistent identity for Polecats and Crew agents.
Schedule GPU jobs on a shared cluster so distributed jobs get all their GPUs at once, fragmentation stays low, and preemption is predictable.
Walk hierarchies and graphs with recursive CTEs, with a termination condition and cycle protection so the query ends.
Implementing comprehensive validation rules across database, application, and pipeline layers to ensure data integrity.
Validate untrusted data once at the boundary, then trust invariants inside and fail loudly if they ever break.
Write C with explicit ownership conventions, bounds discipline, and sanitizers wired into every test run. Use when writing or reviewing C code, or hunting memory corruption.
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.
Let large uploads survive network interruption by chunking and resuming from the last confirmed part.
Python testing with pytest using uv package manager. Use when: (1) Running Python tests, (2) Writing test files or test functions, (3) Setting up fixtures, (4) Parametrizing…
Write the docs that decide whether someone adopts a project: a truthful readme, a working quickstart, and answers to the first questions.
Understand unfamiliar code quickly by tracing real execution paths rather than reading files in order.
Run a team of migration agents that inventories the work, transforms each slice in isolation, verifies it, and merges under strict discipline.
Score incoming vulnerability reports the same way every time, tie each score to a fix deadline, and run disclosure on a predictable clock.
Decide what an AI system forgets and when, through expiry, decay, and explicit deletion, so memory stays current and lawful.
Plan and execute launch marketing by producing a Launch Marketing Pack (launch brief, hook/sizzle, channel plan, PR outreach kit, internal readiness kit, execution checklist,…
Judge whether a service mesh's east-west traffic features justify its operational complexity, versus a library approach.
Read coverage as a map of untested risk that steers the next test, rather than enforcing a percentage target.
Build self-serve documentation that answers questions before they become tickets, organised by what people search for. Use when the same questions arrive repeatedly.
Turn internal knowledge into role-based learning paths with agents that build, test, and keep material current as systems change.
Store time-series data with retention downsampling, compression, out-of-order handling, and the right store choice.
Render other people's cursors and selections so they inform rather than distract, and stay correct as content changes.
Operate as a backend engineer who designs stable API contracts, guards data integrity, and ships services that are operable on day one.
Operate as an incident commander who owns the response to a live outage: severity, coordination, and communication, not the fix itself.
Paginate large result sets so page cost stays constant by using keyset (cursor) pagination instead of OFFSET, with a stable, encoded cursor.
Operate as a support engineer who triages by impact, reproduces before escalating, and turns recurring tickets into product fixes.
Defer expensive work until the moment it is actually needed, so startup stays fast and unused paths cost nothing.
Understand how gradients flow backward through a network so vanishing gradients, dead units, and exploding losses become diagnosable.
Reason about how running time and memory grow with input size, and know when the asymptotic answer is the wrong one.
Set and vary the learning rate over training, since it is the hyperparameter that most determines whether a run converges. Use when loss diverges, plateaus early, or oscillates.
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.
Produce API reference docs that blend generation with curation, an example per endpoint, and documented errors.
Judge someone's ability, including your own, through demonstrated performance rather than confidence or credentials. Use when hiring, mentoring, or deciding what to learn next.
Operate as a mobile engineer who plans around release trains, a real device matrix, and app-store rules that a web engineer never faces.
Construct test objects through builders and factories with valid defaults so each test states only the fields it cares about.
Verify that abstractions actually compile away by inspecting generated code and measuring, and know the costs that remain.
Resist extracting shared code until a third real use reveals the true axis of variation. Use when tempted to add a helper, base class, config object, or generic layer on one or…
Understand how text becomes tokens, and why token boundaries explain model behaviour on numbers, code, and non-English text.
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…
Eliminate SQL injection by sending data as bound parameters instead of concatenated query text, and auditing every raw-SQL escape hatch.
Scale collaborative sessions across instances with room routing, shared state, and controlled fan-out. Use when one server can no longer hold all active sessions.