More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Improve: Timed Autonomous Codebase Improvement

    1

    When the obvious work runs out it looks for fresh evidence; a script, not the model's guess, decides when time is up.

    Free

    Security scanned

    Improve: Timed Autonomous Codebase Improvement

    Example session with this skill installed

    /improve 4h

    • Read your context and instructions
    • Compiled the improve

    An illustrative hourly report in the skill's documented format (repository and task names are examples):

    IMPROVE - hour 3 of 4 - improve/2026-11-14 - tier 2
    Board    http://127.0.0.1:8765
    ------------------------------------------------------------
    Landed this hour (4)
      a1b2c3d  fix(orders): the retry sweep no longer swallows a failed UPDATE
      e4f5a6b  test(billing): cover the invoice boundary at exactly midnight
      9c0d1e2  fix(api): reject a negative page size instead of returning every row
      7f8a9b0  perf(search): reuse the compiled filter across a request
    Rejected (3)
      q-0011  perf: batch the approval query
              gate red: TestApprovalOrdering - expected 3 rows, got 0
      s-0004  security: validate the redirect target
              contradicted auth/callback.py:88, which documents why the check is upstream
      p-0007  perf: cache the tier lookup per request
              counter-scenario failed: two members of one account, second read returns the
              first member's tier (TestTierLookupAccount, added)
    Proposed, needs you (1)
      p-0002  CI has no dependency cache; every run reinstalls 212 packages.
              Needs a workflow change, which is outside the default boundaries.
    Benched
      performance - 3 consecutive gate failures
    Journeys checkout-p95 212ms -> 140ms (-34%)   search-open 0.62s -> 0.62s
    Totals   quality 7/2  coverage 5/1  security 1/0  performance 2/1  docs 0/0   backlog 6 ready
    Lanes    off: contracts (no client in tree)   idle this hour: resilience, docs
    Next     q-0019 unchecked error in the export queue drain
    

    At the deadline the final report adds the total commits, the branch name, the diffstat, every proposed item in full, and the exact commands to review the work:

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

    Rejections are reported as prominently as successes, rejection reasons quote the gate's actual output, and nothing is listed as landed without its commit SHA.

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

    About this skill

    Point an AI coding assistant at your repository, tell it how long to work, and come back to verified commits.

    Most "improve my code" prompts stop after one pass, or quietly pad the diff. /improve runs inside Claude Code or Codex as a disciplined loop that keeps going until your deadline, proves every change with your own tests, and reports honestly every hour, including the hours when it found nothing.

    Claude Code:  /improve 4h
    Codex:        $improve 90m ~/Code/api
    

    What makes it different

    • It works until the clock says stop. The duration is an instruction, not an estimate. When the obvious work runs out it looks for fresh evidence; a script, not the model's guess, decides when time is up.
    • Every change is proven or reverted. Each fix lands as its own commit behind your repository's own gates, then has to survive a mutation check and an independent counter-scenario review. A change whose gate did not run did not happen.
    • Your priorities, not the model's. Ten short intake questions become an ordered focus plan before the timer starts.
    • Safe by default. It works on an improve/<date> branch. It never pushes, never touches main, never adds dependencies or migrations, and never reads secret files unless you say otherwise.

    A live board you steer from

    A local web app at 127.0.0.1 (no account, no npm, no network):

    • Kanban, history, and overview of every task with its evidence and commit.
    • Twenty improvement categories to point the run at: UI polish, security hardening, speed, accessibility, test coverage, and more.
    • Work in parallel: one switch and a slider tell Claude Code or Codex how many subagents or workflow agents to use for finding and reviewing work.
    • Steer mid-run: add tasks, send guidance, change priorities, approve proposals, pause, resume, or stop. By voice too, and from your phone.
    • Light and dark themes, and motion that only moves when something changed.

    It remembers each codebase

    • A knowledge graph per repository: files, tasks, gates, blockers, and what the agent learned, read before every task so it does not repeat a failed approach.
    • It dreams: between runs it infers links, flags contradictions, forgets what went unused, and can restore anything it forgot.
    • A wiki that writes itself from the graph when a session finishes: key knowledge, one page per area, what each session added or removed.
    • Knowledge never crosses repositories. Open another codebase and the board follows you to that codebase's own graph and wiki.

    Built to save tokens

    Every helper the agent calls answers in TOON (Token-Oriented Object Notation): one header, one row per record.

    • Helper answers are typically 25–55% smaller than the same answers in JSON (measured on this project's own run state).
    • The ranked backlog view is about 72% smaller than reading the raw ledger.
    • Long answers take a token budget (--budget 2000) and say exactly what they left out.
    • A standard-library code layer answers "what depends on this?" and "what would break?" without the agent reading whole files.

    How a run works

    1. Agree on outcomes. The ten answers become an ordered focus plan with exclusions and any explicit authorization you granted.
    2. Establish the baseline. Start the clock, discover the repository's gates (build, tests, linters, scanners), confirm they are green, and create an improve/<date> branch.
    3. Discover and rank. Read-only finders look for concrete, evidenced problems in the areas you prioritized; each finding carries a file, a line, and a failure scenario.
    4. Fix and prove. One item at a time: edit, run the gates, break the fix to confirm the test catches it, run a counter-scenario, then commit with a message that says why. Rejected ideas stay in the ledger with their evidence so they are not retried.
    5. Report and continue. An honest report every hour, then more discovery, until the deadline.

    Runs for hours or days

    Foreground for an afternoon, or hand the saved intake to the bundled daemon for runs that outlive your terminal. It is built so a 48 to 72 hour run reaches its deadline: a failed task is blocked and skipped, damaged state is repaired, uncommitted changes are saved to a private quarantine ref, usage limits get bounded backoff, and a crashed daemon resumes with the same deadline.

    What's in the package

    • SKILL.md: the full agent execution contract
    • references/: intake, work selection, verification, ledger schema, knowledge graph, board protocol, report format
    • scripts/: the daemon, clock, board server, ledger, knowledge graph, and code layer (Python standard library only)
    • assets/board/: the local board web app (no build step, no npm)
    • docs/: workflow, board, and runner guides

    Requires: Git, Python 3.9+, macOS or Linux. Optional: the Claude Code or Codex CLI for daemon runs.

    Open source under MIT. Source, issues, and the full test suite: https://github.com/kshaham/improve-skill

    Not for one-off fixes; it is a timed loop. macOS and Linux only (no native Windows). Needs a clean working tree, and a repository with runnable gates (build, tests, linters) gets the most from it, since changes that cannot be proven are reverted. By default it will not push, open pull requests, bump dependencies, install tooling, or change schemas. 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 any payment.

    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

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 2 days ago

    • Free with an Agensi account

    Requires

    Git
    Python 3.9+
    macOS or Linux
    Python
    vitest
    Node.js
    macOS only
    jest
    mocha

    Permissions

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

    File Scopes

    .improve/**
    ~/.config/improve/**

    Runs git, the target repository's own build, test, and lint commands, and the bundled Python helpers. Works on an improve/<date> branch in the target repository; never pushes, never edits main, never reads secret files. 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; cross-repo lessons are stored in ~/.config/improve. Optional IMPROVE_* environment variables tune the daemon. The optional 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

    No. It works on a dedicated improve/<date> branch, never edits main, and never pushes or opens pull requests. You review the branch with the git commands the final report prints and decide what to merge.

    Every change runs your repository's own gates, a mutation check that confirms the test goes red when the fix is broken, and an adversarial counter-scenario. Work that cannot be proven is reverted and recorded as rejected with the evidence.

    Git and Python 3.9+ on macOS or Linux. The scripts use only the Python standard library and the board has no build step. Background daemon runs also need the authenticated claude or codex CLI.

    An empty backlog triggers a deeper discovery pass, escalating from defects to coverage to structure to bounded refactors. Only the deadline, or your stop request, ends a run normally.

    Yes. Unattended cycles are launched with the assistant's approval prompts disabled so the run can continue while you are away. Interactive runs inside your assistant keep your normal permission settings.

    New in Code Quality & Review