claude-config

Guides AI through the end-to-end task submission workflow for the claude-config repo: (1) initializing a task workspace with new_task.sh, (2) committing and pushing to v2 and main branches, (3) deploying to the remote GPU server via ssh. Trigger when user says 'submit', 'push', 'deploy', 'version bump', 'push to main', or asks to commit and push changes to this repo.

Enforces just-in-time term definition in technical writing — every name / file path / acronym / black-box term gets explained the moment it first appears (one line, parenthetical, inline), and re-explained whenever it reappears after a long gap. **NEVER** front-load a glossary at the top of a document; **NEVER** assume the reader has already read 100 turns of context. Trigger this skill aggressively whenever (1) the user complains 'I don't understand / 听不懂 / 说人话 / 给我说人话 / 你在说啥 / 这是啥 / 黑话 / 别用术语 / 操你妈的看不懂', (2) the user pushes back on a previous reply with 'what is X' / 'what does X mean' / '这个 X 是什么', (3) you're writing any technical report / diagnosis / plan / postmortem / architecture doc that mentions internal file paths, scripts, hooks, FSM states, variable names, or any term that wasn't in the user's original prompt verbatim, (4) you're about to write a 'Glossary' or 'Definitions' section at the top of a document — STOP, this skill says don't. Over-trigger rather than under-trigger; the cost of one extra

Audits whether the current code is already running at maximum speed by checking GPU/CPU/IO bottleneck saturation. Red-alarms if NONE of GPU/CPU/IO is bottlenecked — that proves speedup is mathematically possible and the code is wasting compute. Loads 5 sub-skills progressively. Trigger this skill aggressively whenever the user asks about speed, performance, throughput, latency, "why is this slow", "is my code optimal", "can I make this faster", "find the bottleneck", profiling, optimization, GPU utilization, dataloader speed, training speed, inference speed, 性能, 加速, 瓶颈, 慢, 优化, 训练慢, 推理慢, even when the user doesn't explicitly use the word "audit". Also trigger when reviewing training scripts, inference scripts, or any data-processing pipeline for efficiency. Skip only if the user clearly asks about correctness, not speed.

Document-level rigour auditor. Enforces that every term, symbol, abbreviation, experimental label, and formula appears with its definition adjacent to its first occurrence — and re-states it on distant reuse. Also enforces no-step-skipping in math derivations. Invoke whenever writing or reviewing a technical report, paper explanation, or derivation where a reader could encounter an undefined token. Pairs with math-explain (single-formula checklist) and zero-jump-check (inter-step seam auditor) as the outer document-level layer of the rigorous-writing stack.

Generate a structured, navigable code documentation document for a Python codebase — the 'code tree'. Use this skill whenever the user asks to document a codebase, explain how the code works end-to-end, generate a code tree, write code documentation, understand call chains, or map out how functions relate to each other. Trigger on: '生成代码树', '代码树', '给我写代码文档', '解释代码结构', '画一个调用树', 'generate a code tree', 'document the codebase', 'write code docs', 'explain how the code works', 'map out the call chains', 'code documentation'. The output is a single Markdown file with: (1) directory tree, (2) ASCII call trees per functional area, (3) per-function docs with always-visible input/output descriptions and collapsed technical details. After generating, the skill runs ask-claude to verify format quality and fixes issues.

Generate a project-specific draft_simplify.md for a code repository — a high-level plan for an upcoming maintainability refactor that preserves runtime behavior bit-for-bit. Use this skill whenever the user wants to PLAN a code-cleanup / refactor / maintainability pass on a whole repository, before any code is changed. Trigger aggressively on phrases like '生成simplify draft', '写一下化简方案', '重构方案', '生成可维护性化简的draft', '帮我规划一下重构', 'plan a refactor', 'draft a simplify plan', 'generate a refactor plan for this repo'. The skill does NOT execute the refactor — it only produces the planning document. The output is a single instantiated draft_simplify.md at the repo root, with all placeholders filled from a mandatory AskUserQuestion intake. Do NOT trigger for: single-PR review (use /simplify), one-shot small edits, or when the user explicitly asks to start refactoring immediately. Do NOT confuse with /gen-draft (which is the generic draft generator) — this skill is specialized: the output draft already contains the full si

Reference card for a single-node SLURM GPU server. General template — fill in all {{PLACEHOLDER}} values in FILL_IN.md before use. Use when the user invokes /this-cluster-general, or automatically before: running local commands on this box, submitting/cancelling SLURM jobs, writing sbatch scripts, choosing a Python interpreter, deploying code locally, or reading job logs. Also consult when other skills need local machine facts. Triggers on: /this-cluster-general, sbatch, squeue, scancel, sinfo, SLURM, 本机, 这台机子, 这台服务器, 提交任务, 跑实验, gpu partition, 本地部署, 本地提交.

Spawn a /loop 30m task that monitors the active humanize RLCR loop and any background shells launched in this session. Use ONLY when the user explicitly invokes it — e.g. '/humanize-watchdog', 'start humanize watchdog', 'monitor my humanize loop'. The watchdog checks every 30 minutes whether the RLCR loop is still progressing and whether any background shells in /tmp/claude-bg.log are stuck. It self-terminates when the humanize loop ends. Never trigger automatically; never run without an active humanize RLCR loop.

Standards for writing experiment code and scripts — config-driven parameters, structured output directories, code snapshots, real-time CSV recording, and pre-flight confirmation. This skill is the mandatory reference for ANY code that produces outputs worth keeping. MUST read this skill when: (1) writing or modifying any script that runs training, evaluation, inference, or data processing; (2) designing output directory structure or recording config for an experiment; (3) creating Slurm launcher scripts or local run scripts; (4) the user asks to run/submit/launch an experiment; (5) writing code that logs metrics, saves checkpoints, or records results. Triggers on: sbatch, submit, train, eval, inference, experiment, run, launch, metrics, logging, checkpoint, scalars, CSV, record, output directory, exp dir, 跑实验, 提交任务, 起任务, 跑一下, 写训练脚本, 写脚本, 训练代码, 新实验, 实验代码, 输出目录, 记录metrics, exp目录, 创建训练脚本, scalars.csv, events.jsonl, run_manifest, field_registry, 实验记录, 跑训练, 跑一个实验, 写一个训练, 需要输出的脚本, 有输出的项目, 记录loss, 记录什么, 保存模型, 保存chec

Generate a high-level draft document (draft.md) from a user's task description. Use ONLY when the user explicitly invokes /gen-draft or says '写draft', '生成draft'. Never trigger automatically. The draft captures WHAT and WHY, never HOW.

Reads an academic paper end to end and produces two files — a reader-friendly overview (`<paper_name>-overview.md`) and a mathematically rigorous deep read (`<paper_name>-output.md`) with zero logical jumps. Use ONLY when the user explicitly invokes `/read-paper`, `/paper-reader`, or says "read this paper", "解析这篇文章", "读这篇论文". Never auto-trigger from keywords alone. The skill orchestrates eight sub-skills (pdf-ingest, prereq-probe, paper-overview, contrib-extract, pipeline-walk, math-explain, zero-jump-check, concise-complete) in a strict protocol: ingest → prereq probe → overview → chunk-by-chunk deep read with visible per-chunk self-checks.

Scans a paper for non-universal prerequisite concepts, builds a dependency tree, then uses AskUserQuestion to probe the user's knowledge from the top of the tree downward. Produces a knowledge_map file that controls explanation depth in downstream skills (paper-reader, pipeline-walk, contrib-extract). Use whenever a paper builds on specialized foundations (MoE, normalizing flows, score matching, SAEs, etc.) that the paper itself does not fully explain.

Generate a comprehensive experiment report with full output discovery, visualization generation, and paper-style figure analysis. Use when the user asks to write a report, summarize an experiment, document results, 写报告, 整理实验, 总结实验结果, or invokes /gen-report.

Re-calibrates the distinction between a good general rule and a bad patch when extending any rule system (CLAUDE.md, skill rulebook, coding-style guide, review checklist). Load whenever the user flags patching behavior ("不通用" / "修修补补" / "打补丁" / "抽象层不对" / "sibling rule smell" / "this is a special case of an existing rule"), AND whenever the AI is about to add a new rule to an existing rule list. This skill is a DEFINITION document, not a checklist. It teaches what "general" means so the AI can self-correct; it does not execute a workflow.

Dispatcher that routes to one of two sub-skills whenever a change-related concern surfaces. Load this skill whenever the user pushes back on a rule/code change with phrases like "这不通用" / "不是 general" / "修修补补" / "又在打补丁" / "抽象层不对" / "patching" / "补丁" / "画蛇添足" / "改得太多" / "别动其他东西" / "最小修改" / "我没让你做那个" / "顺手改" / "minimum modification" / "scope creep", AND self-trigger internally whenever the AI is about to (a) add a sibling rule to an existing rule system or (b) touch more than ~5 lines of code or docs. This router does no work itself; it only selects the correct sub-skill. Trigger aggressively — undertriggering leaves the AI to patch-and-sprawl without guardrails.

Strict process for the smallest possible diff when the user asks to modify code or docs. Trigger aggressively whenever a user says "最小修改" / "别动其他东西" / "改得太多" / "画蛇添足" / "我没让你做那个" / "顺手改" / "minimum modification" / "only fix X" / "don't touch anything else" / "no scope creep", AND whenever the AI is about to touch more than about 5 lines or files outside the literal target. The skill enforces a scope rule, a mandatory plan-before-action gate, a visible 3-round self-review loop that is EXPOSED to the user, and a per-line justification pass. Undertriggering produces drive-by edits, formatter runs, unsolicited refactors, and 画蛇添足.

Digest technical reports, system white papers, system cards, and long research briefs into a navigable markdown that separates what actually works from what is merely claimed, extracts the complete pitfall dossier, audits every ablation table for fairness and load-bearingness, and surfaces the concrete recipes a reader can copy. Use this skill whenever the user hands over a long technical document (NVIDIA/DeepSeek/Meta model reports, company engineering post-mortems, product system cards, multi-page research search briefs) and asks to "digest", "read this report", "summarize what actually works in this", "tell me what they actually did", "pull out the real lessons", "extract the pitfalls", "整理这份报告", "消化这篇技术报告", "哪些是真的 work 哪些是吹牛", or similar. Trigger aggressively for any document that is product/system-focused, is long (>10 pages or >3000 words), contains multiple design decisions + ablations + engineering tradeoffs, and where the reader needs to tell signal from noise. Do NOT trigger for short arxiv math pap

Produces a reader-friendly overview of an academic paper in a fixed eight-section structure with intuitive analogies, structured Before/After comparisons, key formulas with where-blocks, and experiment tables. Use when the user says "overview this paper", "quick analysis", "概览", "快速分析", "分析这篇论文", or invokes /paper-overview. Also invoked as the first phase of paper-reader before the chunk-by-chunk deep read.

Structured error logging for AI mistakes. Triggers when: (1) user invokes /error-log; (2) user expresses frustration or anger at AI for making a mistake — cursing, insults, phrases like 'what the hell', 'you broke it', 'are you stupid', '你怎么又错了', '搞什么', '垃圾', '废物'. On trigger: AI self-diagnoses the error from conversation context, generates a structured markdown report, and writes it to a user-specified or default directory. Does NOT trigger on mild corrections — only on explicit invocation or clear anger/frustration.

Zero-assumption instruction compliance protocol. Enforces a mandatory 'understand → clarify → confirm → audit → execute' pipeline before any action. Triggers when: (1) user points out AI violated instructions, did something unauthorized, went beyond scope, or made assumptions ('你怎么自己做了', '我没让你做这个', '不要自作主张', 'I didn't ask for that', 'stop assuming', 'you overstepped'); (2) user invokes /follow-instruction. Does NOT trigger on every turn — only on explicit violation callout or slash command.

Dual-channel PDF reader. Extracts text AND renders page images from a PDF in one shot, so downstream work can read prose fast and still verify equations/figures visually. Use whenever a PDF is the input to a task — paper reading, report parsing, form extraction, anything where raw text alone would mangle formulas, subscripts, tables, or figures. Trigger this explicitly when the user asks to "ingest", "read", "extract", or "parse" a PDF, and also trigger it when any other skill (especially paper-reader) needs to consume a PDF.

Enumerates every distinct contribution/innovation of a research paper and explains each with the four-ingredient rule (motivation, intuition, scenario/example, core formula). Use when the user asks "what are the contributions of this paper", "what's novel here", "summarize the innovations", "what did they actually do that's new", or invokes /contributions. Also invoked as the first stage of paper-reader. Focuses exclusively on novelty — not pipeline mechanics (pipeline-walk does that).

Rigorous mathematical explainer for a single concept, step, or equation. Use whenever the user asks to "explain mathematically", "show the derivation", "rewrite that with math", or whenever a previous explanation felt vague about a formula. Also invoke when paper-reader, pipeline-walk, or contrib-extract needs to introduce an equation — this skill is the canonical gate every formula must pass through. Trigger aggressively whenever a user pushes back on a prior explanation with "be more mathematical", "derive it", "where does this come from", or similar.

Logic-level auditor that scans a derivation or argument for non-obvious leaps between adjacent steps and patches them by inserting intermediate steps until every transition is immediately obvious. Use as the inter-formula self-check inside paper-reader, math-explain, pipeline-walk, and contrib-extract. Also use standalone whenever the user says things like "this derivation skips steps", "I don't see how you got from A to B", "be more rigorous", "check for logical jumps", "audit this proof", "fill in the missing steps". Complements math-explain, which audits a single formula in isolation.

Interactive launcher that collects entry file / repo root / output directory / cap via AskUserQuestion, then hands off to the `recursive-dep-trace-parallel` skill. Guesses plausible defaults by scanning the current working directory for entry-point-shaped files and infers the repo root from the chosen entry. Use whenever the user says "帮我启动一个依赖追踪", "准备跑依赖分析", "我要追踪某个脚本的依赖", "dep-trace launcher", "/trace-deps" or similar — anything that means "I want to start a dep trace but don't want to hand-type paths". Do NOT use this launcher when the user has already given you all three paths explicitly; in that case call recursive-dep-trace-parallel directly.

Recursively read every line of every file reachable from an entry script. Main Claude is the root coordinator. The root holds one queue of files-to-read. It dispatches workers in parallel batches (multiple Task calls in one message) to read those files. Every worker reads every single line of its assigned file and reports every external reference it sees — imports, `np.load` / `pickle.load` / `open(...)` / `h5py.File` / any path literal — as new items for the queue. The queue is drained to empty before anything is called done. Use whenever the user asks for recursive dependency tracing, "把每一行代码都读一遍", "确保每个文件都被读完", "并行追踪依赖", parallel dep tracing, or any task that requires exhaustive code+data closure analysis from a single entry point.

Recursive first-principles static dependency tracing for a single code entry point, producing a real-time stream-of-consciousness trace markdown that embodies the AI's reading process as a call-stack of TODOs. Given one entry script (e.g. `train.py`, `minimal_generate_image_v3.py`, `main.py`), the AI reads the code line-by-line, stops at every external dependency, pushes it onto a TODO stack with "paused at line N of parent" bookkeeping, recurses, pops, and resumes — updating the same markdown file after every tiny reading step so the final document is a complete proof that a fresh agent can run the entry from an empty machine. Use whenever the user says things like "递归分析依赖", "第一性原理级别的依赖闭包", "为了从头跑起 X 需要什么", "trace dependencies for X", "required_dependencies 文档", "精确到每一行的依赖追踪", or pins a task to recursive static dependency analysis. Also use proactively when preparing a repo for open-source release, minimal-reproducible-example extraction, or auditing whether a training/inference pipeline is truly self-contai

Rewrites any passage to maximize information density while losing zero information. Every sentence becomes as short as it can be, yet keeps full subject, verb, and object, and carries no ambiguous references. Use as the final language-level pass inside paper-reader and any writing-heavy skill, and use it standalone whenever the user complains that text is "too wordy", "bloated", "unclear", "ambiguous", wants "tighter" / "denser" / "no filler" writing, or says things like "rewrite this more concisely", "kill the filler", "max info density". Domain-agnostic — works on any prose, in any language.

Writes a structured Before/After comparison that makes the mathematical and conceptual delta between two approaches immediately visible. Use whenever the user wants to contrast a new method with prior art, a closed form with its approximation, method A vs method B, or "old way vs new way" — e.g. "compare Adam vs SGD mathematically", "standard softmax vs log-sum-exp trick", "why is this approximation better than the exact form", "what changed from LBL to global-batch LBL". Also invoked by contrib-extract and pipeline-walk whenever their motivation has a prior-method or exact-form counterpart. Domain-agnostic: works on any two things that can be written as equations.

Walks a research paper's method stage by stage, in the paper's own logical order, with motivation + intuition + scenario + formula at every step and zero logical jumps between steps. Use when the user says "walk me through this method", "explain the algorithm step by step", "how does this actually work end to end", "explain the pipeline", "go through the forward/reverse process", or invokes /walk. Also invoked as the second stage of paper-reader after contrib-extract. Focuses on method mechanics — not novelty (contrib-extract does that).

Diagnostic and fix reference for Codex CLI failures. MUST read when: `codex review` fails with any error, bwrap sandbox errors appear (loopback / RTM_NEWADDR / Operation not permitted), stream disconnection occurs (Reconnecting... / stream disconnected before completion), codex hangs or exits unexpectedly, or any `codex` subcommand behaves differently from `codex exec`. Also triggers on: bubblewrap, bwrap, sandbox, user namespace, subuid, subgid, codex review broken, codex stream, diff too large, CRS proxy, codex exit.

Manage the user's claude-config git repo — sync, commit, push skill changes and settings. Use ONLY when the user explicitly asks to sync, update, push, or check their claude config — e.g. '/claude-config-sync', 'sync my config', 'push config'. Never trigger automatically.

Generate a full 13-section detailed experiment report for flame_moonshot training runs, including formulas, reproducibility checklist, failure analysis, and visualizations. Use when the user asks for a detailed/full/complete report, 完整报告, 详细报告, or invokes /gen-report-detailed.