All Skills
350 skills across 18 categories
A Write Is Not Done Until a Majority Agrees
A write that is acknowledged from a single copy looks finished the moment that copy answers, and it can be lost when that one copy fails before the change spreads. A quorum write instead waits for a majority of the copies to record the change before it is called done, trading a little latency for the promise that the write survives the loss of any single copy. This skill covers quorum acknowledgement for agent state: choose the quorum size, count distinct copies rather than replies, treat a partial quorum as a failure, and read the quorum back so a caller that was told the write succeeded can find it.
Agent Security Finding Triage
Triage automated security findings from an agent code review by severity, decide the correct merge gate for each level, and handle hardcoded secrets and dependency CVEs in the right order.
Attach a Freshness Bound to a Reused Answer
A stored answer saves a call, but nothing says how old it may be before it misleads, so a value that has changed since it was stored is served as if it were current. This skill covers freshness bounds for agent answers: give every stored answer a bound on its age, serve it inside that bound and fetch again outside it, let the bound differ by how fast the answer changes, and prefer a fresh answer over a stale one when both are available. A bound is a promise about the oldest an answer may be, not a guess about when it will change.
Autonomous Coding Agent
Build an AI agent that writes, tests, and deploys code
Backfill the Window a Stopped Consumer Missed
When a consumer is stopped or a step is skipped, the producer carries on and a window of work is never read. The gap is invisible, because live counters only ever count what arrived. This skill covers backfilling a missed window for agent runs: find the last processed position and the first unprocessed one before replaying, replay in position order because order is part of the meaning, make the replay idempotent because it overlaps already-applied work, and confirm the position reaches the head with no hole behind it.
Backfill the Window a Stopped Consumer Missed
When a consumer is stopped or a step is skipped, the producer carries on and a window of work is never read. The gap is invisible, because live counters only ever count what arrived. This skill covers backfilling a missed window for agent runs: find the last processed position and the first unprocessed one before replaying, replay in position order because order is part of the meaning, make the replay idempotent because it overlaps already-applied work, and confirm the position reaches the head with no hole behind it.
Bound Metric Cardinality Before Labels Explode
Every label you attach to a metric multiplies the number of separate series the system must track, and a single label that takes a different value on every request turns one metric into one series per call. The cost is quiet: storage grows, queries slow down, and the dashboard that used to load at once starts to time out. This skill covers bounding cardinality for agent telemetry: find the label that varies per request, bucket or drop it, set a budget on the number of series one metric may carry, and alert when the count grows faster than the work does. The goal is a metric that stays readable, not a label set that records everything.
Change a Shape in Two Deployments
A shape shared between an agent and its callers cannot be changed in one step, because the moment the writer uses the new shape the readers that have not moved yet are reading something they do not understand. Expand and contract splits the change across two deployments with a period in between. First the shape is expanded so both the old and the new form are accepted and written; once every reader and writer is on the expanded version, the old form is removed. This skill covers the sequence for agent tools and stored records: expand before you switch, backfill what is already stored, switch the readers, and only then contract away the old form.
Change a Shared Record Shape Without Breaking Old Readers
Two runs that share a record may disagree about its shape, and a change made for a new reader can break an old one that still reads the previous shape. The break is not in the writer, which keeps producing valid records, but in the reader that no longer understands them. This skill covers schema evolution for agent data: add fields rather than rename them, make every reader ignore fields it does not know, remove a field only after no reader reads it, and keep the writer able to produce the previous shape.
Check a Tool Reply Against the Shape You Expect
A tool that used to return a field can start omitting it, renaming it or nesting it differently, and the call still returns success. The run then reads a missing value as empty and continues, so the failure surfaces far from the tool. This skill covers contract checks for agent tool calls: state the fields each call depends on, test the reply against that shape before using it, raise at the call when the shape changes, and treat a changed shape as a version change rather than an accident.
Compare and Set So Writes Do Not Get Lost
Two runs read the same record, both change one field, and both write the whole record back. The second write erases the first change and nothing reports an error, so the lost update is only found later when a value is missing. This skill covers the guard: carry a version or revision with the record, write only when the version still matches what was read, re-read and retry on a mismatch, and never read, modify and write in one unguarded step when more than one writer can reach the row.
Cut a Tool Over Between Two Live Versions
A tool version is replaced while work is in flight, and a single deploy that stops the old version and starts the new one leaves a window with no working version and no way back. This skill covers the blue green shape for agent tools: bring the new version up beside the running one, warm it, move traffic across in one step, compare the two on the same signal, and keep the running version alive so that going back is another single step rather than a rebuild. The switch is only safe when both versions can serve at once and the cutover is one action, not a sequence of half steps.
DevOps Monitoring & Alerts
Monitor infrastructure and receive alerts via chat
Hedge a Slow Request Instead of Waiting on the Tail
Most calls to a tool return quickly, but a small share stall, and a caller that waits on each call in turn pays the whole stall. Hedging sends a second copy of a particular call to a different route after that call has been slow for a set time, then takes the first answer and cancels or ignores the other. This skill covers hedging for agent tool calls: pick the delay from the normal response time, cap how much extra work hedging may add, cancel the losing copy, and keep the step from turning one slow call into a storm of duplicates.
Hold a Warm Pool So a Burst Skips Cold Start
The first task a worker handles after it is created waits for the worker to come up, load what it needs and reach a ready state, and that wait is paid again for every new worker. When work arrives in a burst, a pool that starts workers only after the work lands makes every task in the burst wait for the same slow step. This skill covers holding a small pool of warm workers so the first task is fast, keeping replacements coming before the warm set drops, and retiring warm workers that stay idle so the floor does not become a standing cost.
Keep a Session on One Worker
When work for one session is spread across several workers, each worker holds only part of the state and the session starts to behave as if it has no memory of its own recent turns. Session affinity routes every request that carries the same session key to the same worker while other sessions spread freely. This skill covers sticky routing for agent work: choose the session key, route by it, keep the session on one worker until it ends, and define what happens when that worker goes away so a session can move without losing its place. Affinity is a promise about where a session lives, not a guarantee that it lives forever.
Keep an Append-Only Log of What a Run Did
A run that stores only its current state cannot explain why the state is what it is, and a run that failed leaves nothing to replay. This skill covers an append-only event log for agent runs: record each step as an immutable event carrying the run identifier and a sequence number, rebuild current state by folding the events in order, never edit a past event but append a correcting one instead, and use the log to replay a run in a test environment when a step needs investigating.
Keep Order Per Key While Many Keys Run at Once
Parallel work lifts throughput but breaks any order the caller was relying on, so two events for one account can finish out of turn and the later one loses. This skill covers ordered fan out for agent work: split a stream by a key, let different keys run at once, keep the events for any one key in a single line, and slow or block a key rather than let its events cross. Order is only kept inside a key, so the key must be the thing that must not be reordered, such as an account, a file or a session.
Market Correlation Analysis
Analyze relationships between asset prices (stocks, crypto), prediction market odds, and real-world events. Detect alpha signals through correlation heatmaps, time-series analysis, and anomaly detection.
Move Work Between Workers Without Losing a Job
A worker that leaves while holding a job leaves the job owned by nobody, and a worker that joins while jobs are being moved can receive the same job twice. Both are quiet, because the queue looks healthy in each case. This skill covers graceful rebalance for agent workers: drain a leaving worker before it stops, hand back the jobs it still holds, place those jobs before accepting new ones, and confirm every job is owned exactly once after the move.
PR & Code Review Automation
Automate pull request notifications and code review workflows
Read One Consistent Snapshot While the Run Writes
A run that reads several records to make one decision can land on either side of a concurrent write, so the decision is taken from an older value and a newer one at the same time. Nothing errors, because each value is valid on its own. This skill covers consistent snapshot reads for agent runs: pin a read point when the decision starts, read every input as of that point, discard a snapshot that predates a write the decision depends on instead of patching one field, and retry the whole read rather than mixing versions.
Read One Consistent Snapshot While the Run Writes
A run that reads several records to make one decision can land on either side of a concurrent write, so the decision is taken from an older value and a newer one at the same time. Nothing errors, because each value is valid on its own. This skill covers consistent snapshot reads for agent runs: pin a read point when the decision starts, read every input as of that point, discard a snapshot that predates a write the decision depends on instead of patching one field, and retry the whole read rather than mixing versions.
Record the Intent Before the Effect
A write-ahead intent log records what a run is about to do, and why, before it does it. If the process stops midway, the record is the only thing that tells recovery whether the action half happened or never started, which decides whether to finish, undo or escalate. This skill covers the pattern for agent systems: append the intent and flush it before the effect, give every intent a unique id and an outcome slot, mark the outcome after the effect, scan unfinished intents on start, make replay idempotent, and never act on an intent already marked done.
Rehearse a Change on Mirrored Traffic Before Switching
A new version can pass every test and still fail on the first real request, because the test never carried the shape of live input. This skill covers shadow traffic for agent runs: send a copy of live requests to the candidate version without letting its replies reach the user, compare both answers on the same input, ignore differences that are only formatting, and switch the live path only once the two agree on the traffic the candidate has actually seen.
Replay a Failing Run from Its Transcript Alone
A run fails once and produces a plausible answer the next time, so the failure cannot be studied. What changed between attempts was the clock, a random value and live tool responses. This skill covers deterministic replay for debugging agent runs: record everything a step can read, including inputs, seed, tool responses and clock readings, return the recorded response during replay instead of a fresh one, keep the transcript immutable, and read a run that will not reproduce as pointing at the recording rather than at the bug.
Replay a Failing Run from Its Transcript Alone
A run fails once and produces a plausible answer the next time, so the failure cannot be studied. What changed between attempts was the clock, a random value and live tool responses. This skill covers deterministic replay for debugging agent runs: record everything a step can read, including inputs, seed, tool responses and clock readings, return the recorded response during replay instead of a fresh one, keep the transcript immutable, and read a run that will not reproduce as pointing at the recording rather than at the bug.
Replay Old Work Without Starving Live Work
After a gap a consumer must replay a backlog, but an unthrottled replay competes with live traffic for the same pool and can push live work behind old work, so the catch-up causes a second incident. This skill covers throttled backfill for agent work: give replay a share of capacity rather than the whole pool, pause replay when live lag grows and resume when it falls, checkpoint the position after each batch so a stopped replay continues instead of restarting, and alert when the backlog is not shrinking so a replay that cannot keep up is seen early.
Retire a Tool Call Over a Window Instead of Deleting It
Removing a tool call the moment a replacement arrives breaks every run that still uses the old one, and the breakage appears in those runs rather than at the removal. This skill covers deprecation windows for agent tools: mark the old call as deprecated while it still works, warn the callers that still use it, keep the old path alive for a stated period, and remove it only once no live run depends on it.
Sample the Trace by Outcome, Not at Random
Uniform sampling keeps a fixed share of runs and throws away the rest, which works until the runs you most need to see, the slow ones and the failed ones, are as rare as everything else and get discarded with the routine traffic. Tail based sampling decides after the run has finished, keeping every run that failed or ran slow and sampling the ordinary ones lightly. This skill covers outcome based sampling for agent traces: pick the outcome signals first, keep all of the rare bad ones, sample the common good ones, and account for the sampling rate when a count is read from the data so a sample is never mistaken for the whole.
Sample Verbose Logs Without Losing the Signal
Logging every step of every run produces so much text that the one line which explains a failure is buried, and the cost of storing and searching it grows with the traffic. Sampling keeps a share of the routine lines and discards the rest, but a rule that treats all lines alike will throw away the error lines at the same rate as the noise. This skill covers sampling logs for agent runs: choose the rate for routine lines, always keep errors and warnings, keep the lines around a kept error so it stays readable, carry the run id on every line, and scale any count read from the data by the rate.
Size the Connection Pool Before It Runs Dry
A connection pool is a fixed set of reusable links to a service, and every worker that holds one while it waits on a slow call takes it out of circulation. When enough workers do this the pool empties, new work waits for a link rather than for a server, and the delay looks like a slow backend. This skill covers keeping a pool healthy for agent work: size it above peak use with headroom, set a hold limit shorter than the slowest call, always return a link even on failure, and watch the number of waiters so an empty pool is seen before work starts to fail.
Stop a Low-Priority Task Holding the Lock
Priority inversion is a wait that has nothing to do with load: a high-priority task is blocked on a shared resource held by a low-priority task that has been scheduled out, so the important work sits idle while the unimportant work is simply not running. It is easy to misread as a slow backend or a busy pool. This skill covers the pattern for agent systems: keep critical sections short, never hold a lock across a slow call, give every wait a timeout, raise the holder to the waiter's priority for the time it holds the resource, and alert when a high-priority wait is held by a lower-priority task longer than usual.
Version Workflows for In-Flight Runs
A workflow definition that changes while runs are still executing leaves those runs reading a shape that no longer exists, so a step is skipped or a field is missing exactly when the run is halfway done. This skill covers workflow versioning: record the version each run started with, apply a new definition only to new runs, finish in-flight runs on the definition they began with, and change the state shape only through an explicit branch.
Wait for Every Branch Before Joining a Fan-Out
A run that splits work across several branches and joins as answers start arriving can decide on a partial set and never notice the branch that was slow, and that branch may carry the answer that changes the decision. This skill covers the gather barrier for fan-out agent work: define the full set of branches before starting, wait for each to report success or failure, record which are missing, and never present a partial set as a complete one.