Agent skill that audits your codebase with a capable model and writes executable plans for cheaper models to implement, by shadcn.
What it does
Improve is an agent skill by shadcn that audits any codebase using your most capable model, then writes self-contained implementation plans for cheaper models to execute. It never touches source code itself, the plan is the product. Install via npx and run /improve inside any Agent Skills-compatibl
Running your most capable model on every line of code is expensive and wasteful. Improve splits the job: expensive model understands and judges, cheap model executes. That asymmetry makes high-quality code review economically viable on real codebases.
Improve is an agent skill by shadcn, installed with one npx skills add shadcn/improve command. It works inside any agent that supports the Agent Skills format. You run /improve, it maps the repo, fans out parallel subagents across nine audit categories, vets every finding by re-reading cited locations, and returns a prioritized findings table. You pick what gets planned. The skill never touches a line of source code.
Recon comes first: the skill maps the stack, conventions, and build/test/lint commands that become verification gates in every plan. It also ingests intent docs when present: ADRs in docs/adr/, PRDs, CONTEXT.md, DESIGN.md, and PRODUCT.MD. Decided tradeoffs are not re-flagged as findings.
Audit fans out across nine categories: correctness, security, performance, test coverage, tech debt, dependencies and migrations, DX, docs, and direction (feature suggestions must cite repo evidence, per the README). Every finding carries file:line evidence, impact, effort, and confidence. Subagents over-report, so the advisor re-reads every cited location before surfacing anything.
Plans land in plans/, one file each, with an index, priority order, and a dependency graph. Plans are written for the weakest plausible executor: all context is inlined, every step ends with a verifiable command, and explicit STOP conditions prevent small models from improvising when reality diverges from the plan. Each plan stamps the git commit it was written against.
/improve execute <plan> spawns a cheaper executor subagent in an isolated git worktree, hands it the plan, and then reviews the diff like a tech lead: re-runs every done criterion, checks scope compliance, and returns a verdict of approve, revise (max two rounds), or block. Merging is always the developer's call.
/improve reconcile closes the loop after a session: verifies DONE plans still hold, rewrites around obstacles for BLOCKED ones, refreshes drifted plans, and retires findings fixed independently. --issues publishes plans as GitHub issues with the same self-contained body.
Improve advises and plans; it does not implement. If you need code written immediately without a planning step, the workflow adds friction. The value compounds over sessions: the reconcile loop is where backlog hygiene pays off.
Improve is the clearest expression of a two-tier agent architecture in the wild: one capable model that thinks, many cheap models that execute, and a plan format designed for the weakest executor in the chain. For teams running AI-assisted development at scale, it is one of the more rigorous approaches to keeping costs low without sacrificing audit quality.
Features
Field notes
Reviewed Jun 26, 2026
Best for
Builder outcomes
Watch out
Tested with
Cost
The core value proposition is cost asymmetry: a capable model audits and plans once, then cheaper models execute. This avoids running the expensive model on every line of code across the full codebase.
Improve is an agent skill by shadcn that audits a codebase using your most capable model and writes self-contained implementation plans for cheaper models to execute. It fans out parallel subagents across nine audit categories, vets every finding by re-reading cited file locations, and returns a prioritized table. The skill never writes or modifies source code, its only output is markdown plan files in a plans/ directory.
Install with `npx skills add shadcn/improve` in any agent that supports the Agent Skills format. Once installed, open your agent inside a repo and run `/improve` for a full audit, or `/improve quick` for a cheaper pass focused on hotspots. The skill maps the repo, returns a findings table, and you tell it which findings to turn into plans, for example 'plan 1, 3 and 5'.
Yes, Improve is released under the MIT license by shadcn and is free to install and use. There is no subscription or Improve-operated service, all model inference costs are your own and flow through whichever agent and models you configure. The README notes that the audit step intentionally uses your most capable (typically most expensive) model, while execution targets cheaper models.
Improve is best for teams running AI-assisted development who want rigorous, evidence-backed code review without paying capable-model rates for execution. It shines on codebases that maintain intent docs like ADRs, PRDs, or CONTEXT.md, which it ingests so decided tradeoffs are not re-flagged as findings. The two-tier architecture, expensive advisor, cheap executor, makes systematic auditing economically viable at scale.
A plain model review gives you prose suggestions with no structured handoff to execution. Improve writes plans designed for the weakest plausible executor: all context is inlined, every step ends with a verifiable command and expected output, and explicit STOP conditions prevent a smaller model from improvising when reality diverges from the plan. It also stamps each plan with the git commit it was written against, enabling a mechanical drift check before any executor touches anything.
Improve never implements code itself; every plan requires a separate agent or the /improve execute command to act on it, and merging is always the developer's responsibility. Parallel subagents over-report findings, the vet step filters false positives by re-reading cited locations, but it is not infallible. The skill also makes no guarantees about the quality of execution by downstream agents: it reviews the diff and returns a verdict, but cannot force correctness in a model it does not control.
Agent skill collection for engineers who use Claude Code or Codex, small, composable prompts that enforce TDD, domain modeling, and architecture review.
Best for Engineers already using Claude Code or Codex daily who want to stop architectural and quality driftOpen-source agentic skills framework that brings spec-first, TDD-enforced, subagent-driven software development to Claude Code, Cursor, Codex, and 8 other AI coding harnesses.
Best for Teams wanting a full SDLC enforced automatically on coding agents, from spec through code reviewOpen-source collection of reusable agent skills, shared AGENTS.MD rules, and portable helper scripts for Codex and Claude agents, by steipete.
Best for Developers running multiple Codex or Claude agent projects who need one canonical source for shared rules and skillsA catalog of repeatable AI agent workflows with built-in feedback loops, plus an installable skill for finding, adapting, and designing your own loops.
Best for Teams using Codex, Cursor, or Claude Code who want agents to iterate reliably instead of making one-shot guessesOpen-source PM skills marketplace: 68 AI skills and 42 workflows across 9 Claude plugins for product managers doing discovery, strategy, execution, and launch.
Best for PMs using Claude Code or Claude Cowork who want framework-driven decisions baked into daily AI workflows39 mental-model skills for Claude Code, first principles, Bayesian, OODA, pre-mortem, and more, all invoke-by-name with no setup.
Best for Engineers, founders, and analysts who want Claude Code to reason through decisions using named, established mental models