More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Performance Optimization: Web and Backend

    1

    Fix slowness by evidence: budgets first, profiling over guessing, fixes ordered from less work to cheaper work, and CI guards so the win survives the next deploy.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Performance Optimization: Web and Backend

    Performance Optimization: Web and Backend

    Example session with this skill installed

    Our checkout API got slow over the last two weeks — p95 went from about 400 ms to 2.1 seconds. The team wants to rewrite the pricing module. Where do we actually start?

    • Read your context and instructions
    • Compiled the performance optimization

    Start where this method always starts: not with the rewrite, and not with code. Your budget — assume p95 under 500 ms for checkout; correct it if that is wrong — is breached about 4x, and the shape of the breach matters. A single bad deploy spikes overnight. A two-week climb points at growth: more data, more traffic, or a degrading dependency. The pricing module may be guilty, but nothing yet says so. First probes, in order — roughly an hour of measurement before any fix. One: the database query log for the checkout endpoints, sorted by total time (count times average). Two-week climbs are classically an unindexed filter meeting a growing table, or an N+1 whose cost scales with items per order. Two: if every endpoint climbed together rather than checkout alone, check connection-pool wait time before touching a single query. Three: skim the deploy log for the window anyway — a small change, a new synchronous call, heavier logging, can stay invisible until volume grows into it. The fix, at the highest level that applies. Expect the profile to name one query family owning most of the time. If checkout fetches data it never renders — a full order history behind a totals call — that is level 1: delete the work, no index needed. If the same query repeats per line item, level 2: batch it into one query. Only then level 3: an index matched to the actual filter shape, verified with the query plan before and after. The pricing-module rewrite does not enter the plan unless the flame graph puts pricing there — measure it, and let the number argue. Verify and guard. Re-measure p95 with the same method that produced 2.1 seconds; a stopwatch on one warm request proves nothing. Then make it permanent: a CI budget on the checkout endpoint's query count, and an alert on p95 sustained above budget for 15 minutes, so the next climb is caught in week one instead of week three.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Most performance work is spent tuning the wrong thing, because the bottleneck is almost never where intuition points — it is the N+1 query, the unindexed filter, the 4 MB hero image, the payload nobody needed. This skill enforces the loop that avoids that waste: budget, baseline, profile, fix the actual bottleneck, re-measure, guard. You start by writing the budget down — p95 under the SLA rather than an average, largest contentful paint under about 2.5 seconds, jobs inside their scheduling window — on a one-row-per-surface worksheet, so "fast enough" is a decision procedure instead of a feeling. Measurement is split honestly into synthetic (reproducible, for finding and fixing) and real-user (messy, the only proof users felt it), and a first-probe table maps symptoms to the first measurement worth taking: one slow endpoint, every endpoint slow at once, slow only for some users, slow right after a deploy. Fixes follow a five-level hierarchy that most teams run backwards: do less work, do the work once, do the work cheaper, do it later, do it elsewhere. Backend and frontend pattern sections cover the repeat offenders — N+1 queries, indexing for the query shape rather than the column, connection-pool sizing, unbounded anything, bundle weight, main-thread discipline. A worked example walks a dashboard from a 3.8-second p95 to 1.9 seconds with a single batched query, after the profile showed the team's planned renderer rewrite owned 0.2 seconds of the problem. Every fix runs a pre-change checklist and ends with a guard — a CI budget, a production alert, or a code note with the measured numbers — so the next refactor cannot quietly hand the regression back.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for APIs & Backend.

    - It cannot measure for you: without a profiler, query log, or trace to work from, the honest output is a measurement plan, not a diagnosis. - Thresholds given (p95 budgets, ~2.5 s paint targets) are sound defaults, not your SLA — the worksheet step exists to replace them with numbers your product actually owes its users. - It optimises within your current architecture; if profiling proves the architecture itself is the ceiling, it will say so with the numbers, but the redesign is a separate project. - Load testing for a known traffic event is a companion discipline — this skill finds and fixes bottlenecks, it does not certify capacity.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 24 days ago

    Software
    Git

    Permissions

    Terminal / Shell
    Listed24 days ago
    Updated21 days ago

    What's inside

    Frequently Asked Questions

    That order is exactly what this skill exists to prevent. The fix hierarchy only helps once the profile names the bottleneck; applied blind, the same patterns waste a week tuning code that owns 3% of the time. If you cannot measure yet, the skill's output is a measurement plan — usually an hour of work that saves days of guessing.

    It will give you the evidence to decide. In practice the profile almost always finds the time concentrated in a query pattern, an asset, or a data-shape problem that a rewrite would carry over untouched — the worked example shows a planned rewrite that owned 0.2 seconds of a 3.8-second problem. If the numbers genuinely indict the architecture, you will have the proof a rewrite proposal needs.

    The guard step. Every fix in this method ships with a CI budget, a production alert, or a code note carrying the measured numbers, chosen before the fix lands. Regressions usually return because nothing was watching the metric — the guard is what makes the win survive the next refactor.

    New in APIs & Backend