# ICODE — An AI coding workflow, from plan to proof. > ICODE brings a ticket-based AI coding workflow to Claude Code, Codex and CodeBuddy: staged design, code review after switching models yourself, evidence-based verification and resumable work. Plan, review, build and verify in one resumable ticket. Claude Code · Codex · CodeBuddy Site source version: v2.32.1 [Website](https://ayukyo.github.io/icode-skill/en/) ## Six stages. A traceable path forward. Set the boundaries. Build the change. Keep the reasons behind each step. ### Plan / plan Turn an idea into a reviewable implementation plan. - Input: Goals, constraints and existing code. - Output: 01\_plan.md: scope, approach and verification plan. - Checkpoint: Make exclusions and risks explicit. A design-only request stops here. [Read step rules ↗](https://github.com/ayukyo/icode-skill/blob/main/steps/01_plan.md) ### Review / review Find design gaps before implementation. - Input: The plan, relevant source and interface contracts. - Output: 02\_review.md: issues, risks and recommendations. - Checkpoint: Ground recommendations in the design or code, not impressions. [Read step rules ↗](https://github.com/ayukyo/icode-skill/blob/main/steps/02_review.md) ### Finalize / merge Consolidate review feedback into an implementation basis. - Input: Plan, review findings and agreed trade-offs. - Output: 03\_plan\_final.md: the finalized design. - Checkpoint: Resolve or explicitly retain open questions and scope changes. [Read step rules ↗](https://github.com/ayukyo/icode-skill/blob/main/steps/03_merge.md) ### Code / code Implement the finalized plan with traceable changes. - Input: Final design and the current code baseline. - Output: Source changes, tests and actual execution records. - Checkpoint: Stay within authorized scope. A plan is not evidence of completion. [Read step rules ↗](https://github.com/ayukyo/icode-skill/blob/main/steps/04_code.md) ### Deep check / deepcheck Revisit implementation and related call chains for gaps. - Input: Source changes, design decisions and execution records. - Output: 05\_deepcheck.md and coverage records. - Checkpoint: Check boundaries, regressions and missing evidence; fix and retest findings. [Read step rules ↗](https://github.com/ayukyo/icode-skill/blob/main/steps/05_deepcheck.md) ### Audit / audit Check whether the delivery conclusion has supporting evidence. - Input: Design, code changes and available verification evidence. - Output: 06\_audit.md: delivery conclusion and unverified items. - Checkpoint: Separate verified, pending and blocked. A report is not a device test. [Read step rules ↗](https://github.com/ayukyo/icode-skill/blob/main/steps/06_audit.md) ## Optional paths, not extra required stages ### Optional intake · init / log Organize complex requirements or establish device and source provenance for log analysis. Choose the entry that fits the task. ### Independent verification · verify Explicitly choose build, deploy, listen or test, independently or in combination. Listening or testing alone uses the installed version; it does not implicitly build or deploy. ### Advanced optional review · crosscheck Review a completed ticket independently. Switch agents or models yourself; repeated rounds stay separate from original history and code. No automatic model switching. ## Capabilities Choose your goal. Expand for commands and boundaries; examples are not execution evidence. ### Develop & design Ticket-based development, or just a design. Tell the agent both your goal and where to stop. ``` Use ICODE to design retries for this module. Stop at the plan; do not change code. ``` ``` /icode start Add modulo to the calculator and cover it with tests /icode plan ``` start follows the main workflow; plan can run independently. Design-only requests must stop before implementation. ### Logs & diagnosis Establish the version, time window and evidence source before analyzing an incident. ``` Use ICODE to analyze this failure log. Find the cause without changing code. ``` ``` /icode log ``` Current source, deployed versions and historical logs are different evidence layers. Keep uncertainty explicit when field data is missing. ### Design & code review review examines the current design; crosscheck provides repeatable independent review of completed tickets. ``` /icode review ``` ``` /icode crosscheck ``` For multi-model code review, switch agents or models yourself first. ICODE does not automatically switch models; crosscheck leaves original history and code unchanged. ### Build & device checks Choose the actions you need and keep records tied to actual execution. ``` /icode verify --listen ``` ``` /icode verify --build /icode verify --build --deploy --listen /icode verify --deploy --test ``` Using --listen or --test alone checks the installed version. It does not implicitly build or deploy; deployment must be selected explicitly. Replace <target> with your project's test target. ### Docs & reusable knowledge Choose project documentation, Word, PPT or reusable knowledge to match your delivery needs. ``` Use ICODE to write a newcomer-friendly guide for this project. ``` ``` /icode doc /icode docx /icode ppt /icode study ``` Successful generation is not visual acceptance. A text-only model cannot inspect images directly; keep visual review limits explicit. ### Manage & resume tickets Check state and verification debt, or manage and resume tickets in the local workspace. ``` /icode status --pending ``` ``` /icode list /icode ui Resume the bound ICODE ticket: check its state and execution receipts before continuing. ``` This website does not connect to your local UI or read tickets. Resuming work retains the original scope and stop points. ## Development that outlasts a conversation ### Describe the goal Name ICODE and state the goal and constraints. Your host agent routes to existing steps, preserving stop points and safety gates. ### Ticket-based development you can resume Plans, changes and review records stay with the ticket. Check its state, execution receipts and unfinished work before resuming the authorized scope in another session. ### Multi-model code review Switch agents or models yourself in your host, then run /icode crosscheck on a completed ticket. ICODE does not automatically switch models; repeatable review rounds stay separate from the original ticket history and code. ### Verify with evidence Explicitly combine build, deploy, listen and test, recording actual results and evidence gaps. Listening or testing alone does not implicitly build or deploy. ### Manage tickets locally The optional /icode ui opens a local workspace using existing steps and gates. No tickets need to be uploaded to this website. ### Keep your existing host Use Claude Code, Codex or CodeBuddy. Switch models between stages. Natural-language routing does not require the optional Runtime or a new model service. ## Deliver code with the reasons to trust it. Generic calculator illustration, not a real ticket or test result. A report does not mean a device was verified. ### Design rationale Why modulo is needed, which inputs are allowed, and how review findings were handled. Plans stay with the ticket. ### Code & tests Which source changed, which boundaries were covered and which commands ran. Execution records match actual changes. ### Verification records Record build, deployment and test evidence separately, with actual versions and results, not just a completed label. ### Not verified Without access to the target device, mark it not verified. Deliver the remaining conditions and limitations alongside the code. ## Install once. Start in your project. ### System terminal · preview before installing ``` git clone https://github.com/ayukyo/icode-skill ~/icode-skill cd ~/icode-skill ./install.sh --dry-run --client all ./install.sh --client all ``` Bring a configured AI coding host and model access. Installation may download runtimes and optional MCP dependencies. all installs Claude Code and Codex, adding CodeBuddy only when its configuration exists; --client codebuddy selects it explicitly. The default is Claude only. ### After installation · your host agent's project session ``` /icode help Use ICODE to design retries for this module. Stop at the plan; do not change code. ``` Restart or reload skills in your host; select the skill explicitly or use /icode if needed. Use it only when you name ICODE or resume a bound ICODE ticket. It does not take over unrelated requests. These are host agent instructions, not shell commands. [Full English documentation](https://github.com/ayukyo/icode-skill/blob/main/README.md) ## Start with a sentence. Or choose a step. ### Design only ``` Use ICODE to design retries for this module. Stop at the plan; do not change code. ``` ### Full development flow ``` /icode start Add modulo to the calculator and cover it with tests ``` ### Listen to the installed version ``` /icode verify --listen ``` ### Review after switching models yourself ``` /icode crosscheck ``` ### Find verification debt ``` /icode status --pending ``` ### Resume interrupted work ``` Resume the bound ICODE ticket: check its state and execution receipts, then continue from the interruption within the original scope and stop point. ``` ### Open the local workspace ``` /icode ui ``` Gates and reports support verification; they do not guarantee defect-free code. Missing tools, unperformed checks and evidence gaps must stay explicit. Hosts, models and physical devices require their own validation. ## Version notes ### v2.32.1 / 2026-10-08 Fix automatic installation, hash verification and persistent registration of the owned Word renderer. Public distributions require real rendering qualification. The current renderer recipe supports Ubuntu-compatible Linux x86\_64; other platforms remain pending. ### v2.32.0 / 2026-09-20 Natural-language entry: name ICODE and describe your goal and constraints while keeping existing commands and gates. The date is this note's review date, not the release date. A static website. No login or tracking. Your ICODE tickets are never read or uploaded. [MIT](https://github.com/ayukyo/icode-skill/blob/main/LICENSE)