More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Improve-Max: Multi-Day Measured Performance Bets

    1

    Come back to a faster system with the measurements to prove it, or to the numbers that show a bet was not worth placing.** Small fixes make code tidier.

    $7.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Improve-Max: Multi-Day Measured Performance Bets

    Example session with this skill installed

    /improve-max 3d ~/Code/api --target 5x --kinds design,data

    • Read your context and instructions
    • Compiled the improve-max

    An illustrative daily report (repository, journeys, and numbers are examples):

    IMPROVE-MAX - day 2 of 3 - improve-max/2026-11-14 - target 5x
    Board    http://127.0.0.1:8765
    ------------------------------------------------------------
    Journeys (baseline -> now, target)
      feed-open     0.62s -> 0.10s   6.2x   target 5x   met
      api-p95       212ms -> 140ms   1.5x   target 5x   ceiling about 2x: 61% of the time is the remote billing call
      cold-launch   1.84s -> 1.84s   1.0x   no target
    
    Bets
      b-003  landed   design   feed-service: assemble the feed from one query instead of 40
             spike 2.5h, 640 lines, gain 6.6x (threshold 3.0x)
             4 pieces crossed, shadow 0 diffs / 1,240 cases, corpus red under mutation
             landed gain 6.2x, tag max-b-003-landed
      b-004  killed   data     api: covering index for the approvals query
             spike gain 1.2x, below the 1.7x threshold; runs recorded, branch deleted
      b-005  placed   wire     api: batch the three approval calls into one request
             spike gain 1.9x; piece 2 of 5 in progress; clock ends 2026-11-16T10:10Z
      b-006  proposed stack    billing client: needs a live sandbox to record a corpus; you can record it, the loop cannot
    
    Stack    unchanged (Python); feed-service handler redesigned, 9% of the service's lines
    Tomorrow finish b-005 pieces 3-5, then ordinary /improve work in api until the deadline
    

    The final report is the daily report plus the diffstat and the commands to review the run branch:

    git log --oneline <baseline_commit>..improve-max/2026-11-14
    git diff <baseline_commit>..improve-max/2026-11-14
    

    Killed and proposed bets are reported with their numbers, as prominently as landed ones.

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

    About this skill

    Give your coding agent a weekend and a speed target. Come back to a faster system with the measurements to prove it, or to the numbers that show a bet was not worth placing.

    Small fixes make code tidier. They rarely make it many times faster. That takes the changes nobody schedules: rewriting the hot path in a faster language, replacing a framework, reshaping the data model, changing the wire format. improve-max is the courageous variant of /improve: it takes those on over days, without gambling your codebase. The system it hands back may be written differently from the one it was given. It must behave the same, and it must be faster by a margin measured against a baseline taken before the work started.

    Claude Code:  /improve-max 3d ~/Code/api --target 5x
    Codex:        $improve-max 4d --target cold-launch=10x,api-p95=3x --kinds design,data
    

    This is the complete premium package: the full /improve skill (timed improvement loop, daemon, local board, knowledge graph, wiki) plus improve-max. You do not need the free skill as well.

    Twelve transformation bets, one click each

    The premium board's focus panel offers twelve bets sized for multi-day runs: rewrite the hot path in a faster language, replace the framework, reshape the data model, change the wire format, re-architect a subsystem, build a caching tier, go parallel end to end, cold start to instant, swap heavy dependencies, local-first and offline, rebuild the rendering pipeline, rebuild the build and test pipeline. Pick the ones you want, set how many agents may work in parallel with one slider, and steer the run as it goes. A bet never skips its spike, its kill criteria, or the limits you set.

    The premium board

    An onyx-and-champagne edition of the live board: serif display type, gold foil that catches the light, a spotlight that follows your pointer across the bets, and the same no-account, no-network local app underneath. Bets show their phase, their spike numbers, and each landed piece beside ordinary tasks.

    How a bet works

    Courage here means placing a bet whose payoff is large and whose cost is days, on evidence gathered in hours. Every big move follows the same shape:

    1. Pin the behaviour. Before a line of the subsystem changes, the skill records what it does today as a characterization corpus with a replay test, and confirms the replay goes red when the current code is deliberately broken.
    2. Spike the bet. A throwaway prototype of the hottest path, time-boxed to a few hours, measured against the journey harness with interleaved runs. The bet is placed only if the measured gain clears the threshold. A bet killed on numbers cost three hours and saved three days.
    3. Strangle, do not replace. The new implementation lands piece by piece behind the existing interface. After each piece the gates are green, the corpus replays, and old and new are run side by side and diffed. The system is never more than one commit from working.
    4. Land on numbers, or kill. A bet lands when the corpus passes, the shadow run is clean, and the journey moved by at least what the spike promised. Kill criteria are set at placement: its clock, two consecutive piece failures, or unexplained shadow differences.

    Parameters

    ParameterDefaultWhat it sets
    --target3xThe goal as a multiple of the baseline journey time, for every journey or per journey (journey=Nx,...).
    --spikemax(1.5x, target/3)The gain a spike must show for its bet to be placed.
    --kindsall sixWhich kinds of bet may be placed: stack, framework, design, data, wire, dependency. --kinds design,data gets a faster system in the language you have.
    --stop-at-targetoffStop when every targeted journey has met its target instead of continuing with ordinary improvement work.

    Honest about the ceiling

    The target is a goal, not a promise. The opening report states, per targeted journey, whether the target is plausible, what it would take, and where the ceiling is. A journey that is I/O-bound on a remote service does not get a multiple from any language, and the report says so before the first spike, not after the third. Every report shows the target next to the current number so the gap is visible.

    Rules that never bend

    • Never touches main; work lands on an improve-max/<date> branch, with each bet on its own branch
    • Never pushes, force-pushes, or opens a pull request; you review and merge
    • Never reads secret files and never touches a live environment; migrations run against a copy of development data
    • Never retires a test without a successor that provably covers the same assertion
    • Dependency bumps, migrations, and schema changes are allowed only as part of a bet whose spike showed the gain, with down migrations tested both ways

    Everything in /improve is included

    • Verified commits until the deadline: every change proven behind your own gates or reverted.
    • A knowledge graph and wiki per codebase: what the agent learned, read before every task; it dreams between runs and never mixes one repository's knowledge with another's.
    • Built to save tokens: every helper answers in TOON, typically 25–55% smaller than the same answers in JSON, so long runs spend tokens on work, not bookkeeping.
    • Work in parallel: one switch and a slider tell Claude Code or Codex how many subagents or workflow agents to use.
    • Steer from anywhere: tasks, guidance, priorities, pause and stop, by voice or from your phone.

    What's in the package

    • max/SKILL.md: the improve-max execution contract
    • max/references/bets.md: the bet schema, spike protocol, and kill criteria; the characterization and shadow-comparison guide; and the twelve transformation bets the premium board offers
    • SKILL.md, references/, scripts/, assets/board/, docs/: the complete /improve skill it builds on, including the daemon for multi-day unattended runs and the local board, which shows bets alongside ordinary tasks
    • assets/board/premium.css, assets/board/premium.js: the premium board edition

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Code Quality & Review.

    Built for runs of a day or longer; for hours, use the included /improve. Targets are measured goals, not promises: a journey bound by a remote service will not get a multiple, and the opening report says so. Needs measurable journeys (it builds a harness first if the repository has none) and subsystems whose inputs can be recorded without a live environment; bets it cannot pin or gate are written up as proposals instead of placed. macOS and Linux only. Never pushes, opens pull requests, or touches a live environment. Runs use your own Claude or Codex usage for the whole duration.

    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 2 days ago

    Software
    GitPython 3.9+
    Claude Code CLI
    orCodex CLI
    vitestNode.jsjestmocha
    Optional
    jq

    Runs are a day or longer, so use the bundled daemon with the authenticated claude or codex CLI on PATH. jq is only for the optional ledger recipes. The board needs no npm, account, or network.

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Browser
    Network Access
    Environment Variables

    File Scopes

    .improve/**
    tests/characterization/**
    ~/.config/improve/**

    Runs git, the target repository's own build, test, and lint commands, and the bundled Python helpers. Works on improve-max/<date> branches in the target repository; never pushes, never edits main, never reads secret files, never touches a live environment. Unlike /improve, a placed bet may change dependencies, add migrations (run against a copy of development data), and rewrite a subsystem in another language. The bundled scripts serve the board on 127.0.0.1 only (you view it in your browser) and make no outbound network calls. Run state lives in the repository's .improve/ directory, the characterization corpus is committed under tests/characterization/, and cross-repo lessons are stored in ~/.config/improve. The background daemon launches unattended assistant cycles in the target repo with approval prompts disabled (claude --permission-mode bypassPermissions, or codex --ask-for-approval never).

    Listed2 days ago

    What's inside

    Frequently Asked Questions

    /improve makes low-risk, proven improvements over hours and never changes dependencies, schemas, or stacks. improve-max works over days toward a measured speed target and may rewrite a subsystem, replace a framework, add a migration, or change the wire format, each as a bet that must prove its gain in a spike first.

    No. This package contains the complete /improve skill, its daemon, and the local board, plus improve-max. If the free skill is already installed, replace it with this package's copy.

    The target is a goal, not a promise. The opening report says per journey whether the target is plausible and where the ceiling is. The run continues toward the best measured gain available, and every report shows the target next to the current number.

    Before a subsystem changes, its behaviour is recorded as a characterization corpus with a replay test that is confirmed to fail when the code is deliberately broken. The new implementation lands piece by piece behind the old interface, and old and new are run side by side and diffed until there are no unexplained differences.

    No. Work stays on local improve-max branches; it never pushes, opens pull requests, deploys, or touches a live environment. Migrations run against a copy of development data it made itself. You review the branch and merge.

    New in Code Quality & Review