icode-skill

ICode — AI Coding Workflow for Claude Code, Codex, CodeBuddy and WorkBuddy

6-step workflow: Plan → Review → Finalize → Code → Deep Check → Audit. Run all at once, or step-by-step and switch models between steps.

Website & workflow diagrams · 中文官网 · 中文说明 · Installation

ICode is an open-source AI coding workflow Skill for Claude Code, Codex, CodeBuddy and WorkBuddy. Ticket-based development connects requirements, design, implementation, code review and evidence-based verification, with saved state for resuming interrupted work across sessions.

Technical diagrams can reuse a local SVG across Markdown, Word and PowerPoint. The optional DOCX/PPT components validate static SVGs and generate traced PNG fallbacks using pinned local tooling. Experimental SVG+PNG embedding keeps consumer compatibility pending until managed LibreOffice and final-page checks pass. See SVG authoring and inspection.

Generation and acceptance use open-source resvg, managed LibreOffice and local fonts such as Noto CJK. Microsoft Office/WPS are optional compatibility checks.

For multi-model code review, switch agents or models yourself, then run /icode crosscheck on a completed ticket; ICODE does not automatically switch models. The optional /icode ui provides a local ticket workspace. Use ICODE only when you name ICODE or resume a bound ICODE ticket; it does not take over unrelated requests.

Why ICode?

The bilingual public site can be built locally. See site preview and opt-in publishing for GitHub Pages, RSS and optional search notifications. Publication is disabled by default; once enabled, each push to main updates the site automatically. Formal Release and manual runs remain available, but only the latest commit on the default branch may publish; stale runs are rejected. Other branches and PRs do not publish. The site never reads your tickets and does not replace the installer or local UI.

Find the right workflow

Directory login is not listing, and listing is not a recommendation or a complete installation. See the current discovery and distribution boundaries; use the source installer, not a downloaded SKILL.md alone.

Quick Start

# 1) Clone the open-source installer
git clone https://github.com/ayukyo/icode-skill ~/icode-skill
cd ~/icode-skill

# 2) Install ICODE, shared skills, and MCPs for Claude Code + Codex
./install.sh --client all

# 3) Run a full flow
/icode start Implement a feature module

You can also name ICODE and describe the goal in plain language. The current host agent routes to the existing steps and gates; no extra model service is needed:

Use ICODE to design retries for this module. Stop at the plan; do not change code.
Use ICODE to test the version already on the device. Do not build or deploy.
使用 ICODE 把当前工单做成 PPT，给测试同事看。
/icode 帮我查看当前工单还有哪些验证没完成

See the complete natural-language guide for every capability, combined requests, constraints, and resuming a ticket. /icode help also exposes these examples. Automatic discovery depends on the host loading the installed skill; if it does not, explicitly select the ICODE skill or use /icode. Existing commands remain supported.

Or run step by step (switch models between steps anytime):

/icode plan Implement a feature module   # Step 1: Draft plan
/icode review                                       # Step 2: Review plan (soft cap 3 rounds; auto-extends if issues remain)
/icode merge                                        # Step 3: Merge & finalize
/icode code                                         # Step 4: Code implementation
/icode deepcheck                                    # Step 5: Iterative re-review
/icode audit                                        # Step 6: Final audit & fix

Other entry points:

# Local workbench (Windows: WebView2 window; Linux/macOS: loopback browser)
/icode ui

# Trimmed full flow (fast mode: single-file/small changes; not a fixed cost guarantee)
/icode fast "Add isqrt function to calc.c"          # plan→review(1 round, no adversarial)→merge→code→deepcheck(Reverse only)→audit

# Requirement unclear? Draft it in conversation first
/icode init Record sensor data re-bag                # Step 0: kick-off draft + dialogue
# After the init analysis and discussion, turn the latest eligible draft into a beginner-facing guide
/icode init --guide                                  # Refreshes deliverables/guide.md; does not create another ticket

# From a bug log: analyze root cause first, then fix
/icode log ~/work/log/service-anomaly "no response after startup"   # Entry: log root-cause analysis → fix requirement

# Project-level knowledge base (standalone step, runs anytime)
/icode doc myproject                                 # Generate/update this project's knowledge base chapters

# DOCX delivery (standalone; preserves `/icode doc` knowledge-base semantics)
/icode docx docs/release-guide.md                    # P0: faithful DOCX beside the Markdown source
/icode docx current bug delivery Word                # P1: latest unique ICODE ticket → .icode_output/docx/

# Backup all work orders before deleting a project (safety net — run BEFORE deleting)
/icode bak                                           # Snapshot current project's entire .icode_output/ to ~/.claude/icode_data/project_backup/
/icode bak --project ~/work/myproj                   # Backup a specified project
# Repeatable: each run creates a new timestamp snapshot (rsync --link-dest hardlink dedup).
# After the project is deleted, history retrieval still finds full work orders from the backup (project-first, backup fallback).

# Opt-in worktree isolation (any of the entry points above)
/icode start --worktree Implement a feature module   # Full flow + isolated branch/dir
/icode fast --worktree  "Add isqrt function to calc.c"         # Fast mode + isolated branch/dir
/icode plan --worktree  Implement a feature module    # Step 1 only + isolated branch/dir
/icode init --worktree  Record sensor data re-bag              # Step 0 + isolated branch/dir
/icode log --worktree   ~/work/log/service-anomaly "no response"  # Log + isolated branch/dir
# Without --worktree, tickets are created in-place by default — no prompt.
# Triggers also accept natural language ("use worktree isolation"), with reverse declarations taking precedence; AI shows a status line on entry. Projects can block via `/icode limit worktree 强制禁止`.
# New worktrees are created on the current remote-tracking baseline (@{u}) with upstream tracking, so git status/pull/merge stay correct.
# Worktree lifecycle (after creation):
/icode worktree --update    # Move the active implementation to a new checkout on the latest remote baseline (tracked upstream)
/icode worktree --close     # After you committed/pushed/merged: verify online evidence + safe cleanup + record baseline
/icode worktree --reopen    # Restore a closed ticket's active checkout on the latest baseline (then /icode patch)
/icode worktree --merge         # Fetch online targets, preflight conflicts, merge safely, then recheck; never commits or pushes

The Workflow

  /icode log (optional)        /icode init (optional)
  log root-cause analysis ─┐    requirement draft ─┐
                           └──────────┬────────────┘
                                      ▼
  ┌────────┐   ┌────────┐   ┌────────┐   ┌────────┐   ┌────────┐   ┌────────┐
  │ Plan   │ → │ Review │ → │ Merge  │ → │ Code   │ → │ Deep   │ → │ Audit  │
  │ Step 1 │   │ Step 2 │   │ Step 3 │   │ Step 4 │   │ Check  │   │ Step 6 │
  └────────┘   └────────┘   └────────┘   └────────┘   │ Step 5 │   └────────┘
                                                       └────────┘
       /icode start = steps 1→6 chained  |  /icode fast = trimmed chain

Every main ticket step produces a real artifact in .icode_output/.icode_output_N/ (plan → review → final plan → code → deep-check report → audit report), tracked by .ico_metadata.json for cross-session recovery and resumable runs. Detached deliverables and crosscheck rounds use their documented sibling directories and do not pretend to be tickets.

Features

• Closed-loop delivery: (optional) Requirement Draft → Plan → Review → Finalize → Code → Deep Check → Audit; each step callable independently, runs in the main session without model switching