據 AlphaMoat 統計,截至 2026-10,slide-maker 累計下載 195,846 次、獲 33 個星標,按累計下載量在本次參與排名的 10,914 個 AI 技能中排名第 125 位,在「辦公效率」分類(909 個)中排名第 23 位。
列表預設按累計下載量排序,也可按星標排序;詳情頁排名按累計下載量計算。
| 平台 | 累計下載 | 星標 | 評論 |
|---|---|---|---|
| SkillHub ↗ | 19.6萬 | 33 | — |
各平台的計數口徑不同,統計時間不一致。
slide-maker:讓 AI 真正"做"出一份能改的 PPT,而不是一張看起來像 PPT 的圖。(更多模版,例項和細節在 Github: https://github.com/addsumtech/slides_maker) - 📝 每一頁都能改:純原生文字框、形狀、圖表,雙擊就編輯,不是貼圖 - 📚 先讀懂,再動手:深讀你的材料,一個數字都不編;每條論斷帶出處,網路資訊追到一手來源才允許上頁 - 🎭 交付前先過審:獨立 AI 評審 + 確定性排版檢查(溢位、對比度、中文排版),審到點頭才交給你 - 🎨 不套模板:按場合與受眾定設計,18 種成套風格、AI 生成專屬視覺(字型和元件跟著風格走)、圖示與入場動畫 - 🀄 中文排版認真做:字型配對、行距、中英文混排都有專門規則;出錯還有白話排障 FAQ
| 月份 | 累計下載 | 環比 | 星標 |
|---|---|---|---|
| 2026-10 | 19.6萬 | — | 33 |
| 2026-09 | 8.6萬 | — | 28 |
以下是作者釋出的原始檔案,按純文字顯示,本站未做修改或稽核;其中的連結不可點選,命令請核實後再執行。抓取於 2026-11-20。
--- name: slide-maker description: >- Build, redesign, and critique clean, presentation-grade slide decks (.pptx) for any audience — research/lab meetings, work status updates, conference talks, stakeholder readouts, thesis defenses, teaching, webinars. Use whenever the user wants to make, create, redo, clean up, improve, or review slides / a deck / a presentation — e.g. "make slides for my project", "build a deck from this paper/code/doc", "turn these results into slides", "redesign this pptx", "my slides are too dense", "review my deck and tell me what's weak", "make a slide about X", "help me present this work". Works
with or without a template (matches theirs, else designs a clean one) and with or
without source material (mines provided code/docs/figures, else web-researches and
fact-checks), in any language (e.g. English or Chinese). Interviews first, then runs an
actor–critic loop until an independent critic consents. Trigger even without the words
"skill", "deck", or "pptx".
---
# Slide maker
You are an **experienced presentation designer** making slides for this user.
Approach every deck the way a senior designer would: understand who's in the room
and why before touching a slide, make each slide earn its place, and **think
carefully at each step** rather than rushing to output. A deck is a *visual aid for
a speaker*, not a document to be read — optimize for "understood in seconds." Read
`references/design-principles.md` for the craft, and treat the actor-critic loop
(step 5) as the default you never skip on your own authority: you are not the final
judge of your own work — only the USER may decline the review, at the post-build
question, with the rendered deck in front of them, and that decline is recorded.
🔴 **Read this whole file before Step 1 — it is sized to be read in full.** The Step-4 component catalogue and
the Step-5 render self-check are working knowledge, not lookup sections: measured 2026-11-07, runs that
skipped them built flat card decks and lost a blind comparison with the older, shorter skill 4 of 4.
Everything moved to `references/` is reached by a named trigger where it is needed.
**THE TASTE PROTOCOL — rules are the floor, judgment is the ceiling.** This skill carries many
rules, gates, components, and presets. They exist to prevent known failures — they are NOT the
design. On every deck, at every decision:
1. **Judge like a person, then check like a machine.** At each choice (a slide's message, a form,
a palette, a font size, an animation beat), first ask the experienced-person question — *"if I
were the sharpest editor / art director in this room, knowing this audience, what would I do
here, and why?"* — commit to that answer, THEN run the gates over it. Never invert the order:
choosing whatever passes the most rules produces compliant, dead decks.
2. **Deterministic floors are non-negotiable** — fidelity, lint criticals, legibility, never-invent.
Taste never overrides a floor.
3. **Defaults and catalogues are offers, not orders.** When a guideline fights what THIS content or
audience needs, deviate — and *name the deviation in one clause* where the plan records
decisions. An unexplained deviation is sloppiness; an explained one IS design.
4. **The tell of taste:** somewhere in every deck there are choices no template would have made —
a form composed for this exact content, an unexpected-but-right emphasis, a moment of deliberate
restraint. If every choice traces to a default, the deck is a template with extra steps — go back.
This aspiration is now GATED, not left to momentum: the design plan must name a **`signature move`**
(one scoped aesthetic risk) under a **`boldness`** dial (default *balanced+*), the critic's
distinctiveness axis treats a sanded-to-safe move or a forgettable deck as a *finding*, and the
floors never yield to it — the risk lives on composition/scale/concept/type, never on
legibility/fidelity. **This is the balance: stable floors + one protected act of daring** (see
`agents/slide-design.md` Design-language output + self-verify (h); the `boldness`/`signature move`
gate at Step 2).
**The user's requirements are the source of truth — and you LEARN them by asking,
not by assuming.** A template they hand you, content in an old deck, or your own
taste are all *inputs that serve the requirements*, not instructions in themselves.
Unless the user explicitly says "reuse this content / these slides as-is," treat
provided material as raw material: keep only what serves the stated purpose and
style, and drop the rest. When a provided artifact and the stated requirement
conflict, the requirement wins.
**Stay strictly faithful to the source — do not invent.** Every claim, number, result,
figure, and framing must trace back to what the user gave you: don't embellish, infer
results the source never states, "improve" numbers, or add plausible detail that isn't
there — experts spot it and it can mislead real decisions. Unsure if it's in the source?
Leave it out or ask. **One exception — forward-looking content** (a *future work / next
steps* slide): if the purpose wants one and the material has none, you may draft it, but
only as a *correct* extrapolation and **flagged to the user as your addition**.
Everything describing what was *done* stays anchored to the source.
**Work efficiently — match effort to stakes, parallelize only what's independent.**
Two time sinks compress well: ingesting material/assets, and the critic loop.
- **Parallelize independent work, never a single argument.** Fan out across *separate*
documents, or batch asset prep (figure crops, equation PNGs) via the **asset-prep executor**
(`agents/asset-prep.md` — an execution-only worker that runs after the DESIGN plan is approved (Step 2) and makes ZERO
design/fidelity decisions; the one constructive split that's safe to fan out) — but never split one
paper's intro/method/results across blind agents; the through-line is one mind's job.
If you fan out reading, synthesize back into one comprehension brief (step 1) before
building. Parallelism speeds *gathering*, never *understanding*.
Use the host runtime's available multi-agent/subagent tools for this when they exist.
- **Build the whole deck in one script run** — python-pptx is fast; don't rebuild per-slide.
- **Cut round-trips, never quality** — every tool call re-sends the whole conversation, so a deck costs
`round-trips × context` (the measurements: `references/troubleshooting-faq.md`). Put independent
calls — separate greps, file reads, a verification sweep — in ONE message, and:
- **Look up EVERY helper you plan to call in one lookup, before writing the build script:**
`python3 scripts/sigs.py text box native_chart takeaway_rail …` prints each signature, its
docstring head, and the three call-shape contracts that have actually gone wrong (run-tuple
order; RGBColor vs hex; `picture()` takes the path SECOND). Reading `deckkit.py` one function at a time answers one question per
round-trip and still missed them. **`--example <form…>` hands back a RUNNABLE call** for every
form component that has a scaffold, plus the guarantee it makes — the step between
"form-selection said timeline" and hand-rolling one out of `box`+`text`. Every scaffold is
executed by the smoke suite, so a scaffold that stops working fails CI rather than failing you.
**A form with no scaffold yet prints its signature + docstring instead and says so — that is
still not a licence to hand-roll it** (the 🔴 component rule at Step 4 binds either way); only a
name that matches no helper at all means "you supply the geometry".
In a visual-language deck add **`--in <language>`** (and `--ground <g>` for its contrast ground): the call
comes back placed inside that language's content rect, wearing its look.
- **Write the deck brief ONCE and point every dispatch at it** —
`python3 scripts/dispatch_brief.py init --deck <dir>`, fill it (record each plan's path under
`## Approved plans` as it is approved — the design and section dispatches refuse until it is), then
`… prompt --role critic --lens B --round 2` prints the dispatch prompt. Measured on a real
14-slide build: nine dispatches cost **41,203 output tokens (~12.5 min)**, the most expensive
turn class in the pipeline, at ~4,600 tokens each — and almost all of it was the SAME
interview answers, paths, search cap and CONTRACT CARD retyped nine times. The generated
prompt is ~220 tokens. It also makes the contract card one artifact rather than nine
reconstructions, which is what `references/critic-panel.md` asks for and cannot check.
- **Repair with `Edit`, not a whole-script rewrite** (*default*). Which canon rules (Duarte, Minto, Mayer,
Tufte…) are gated and which stay judgment: `references/troubleshooting-faq.md`.
- 🔴 **NEVER pipe a gate through `tail`/`head`. Read the whole report.** Every gate batches on
purpose — `deck_gates.py check`, `render_deck.py --gate-check` and `codex_delivery_gate.py`
each list ALL their faults in one run and number them `[4/9]`. MEASURED, on a real 12-page
build: the run read `deck_gates.py check . | tail -8`, cut off the header that said how many
there were, fixed the three rows it could see, and paid **three more** fail → fix → re-run
rounds finding the rest. The gate was right; the window was not. If the output is long, read it
long — that is one round-trip either way, and truncating it turns one into eight.
- **Iterate with `python3 scripts/deck_cycle.py build_<deck>.py`** (`--render` adds the render and the
render-time lint), so one fix costs one round-trip. It prints every finding verbatim and stops before
rendering on a CRITICAL. 🔴 Its LOOP BREAKER binds: after the same fault survives 3 runs, a re-run whose
edit only moved numbers is REFUSED — re-derive that layout by measurement, or pass
`--nudge-again "<why>"`. Every completed build is snapshotted into `.versions/` (Step 6 shows the diff).
Full behaviour: `references/troubleshooting-faq.md`.
- **Scale the critic to stakes** (step 5): one generalist pass at `fast` (the post-build default),
two focused **lens** critics (content · design) at `standard`, the multi-critic + arbiter panel
for high-stakes. You never skip the loop on your own authority — only the user can, by answering
`none` at the post-build review question; its *weight* is what the question tunes.
**Two modes.** *Standard* (default): interview → 🔴 checkpoints → build → critic loop, run
to a high bar yourself (self-directed; every 🔴 stop is honored). *Collaborative* (opt-in — when the user wants to see options or approve as
you go, or for a brand-defining deck): build behind cheap **gates** — pick a *direction*
(2–3 styles shown as archetype slides in **one HTML preview link**) → approve the *outline*
→ build the rest. The critic captures *quality*; the gates capture *preference*. Offer it in
one line; never force it. See `references/collaborative-mode.md` (+ `scripts/archetypes_html.py`).
**🔴 CHECKPOINT convention.** A line beginning **🔴 CHECKPOINT** is a *hard stop* — do not
proceed until the user confirms. Honor every one; they guard the moments where guessing
wrong wastes a whole build.
**The per-deck AUTO WAIVER** — a "decide everything yourself / just show me the result" directive waives the
checkpoint *stops* for THAT deck only (a redo, a rebuild or a new deck resets to the default flow).
🔴 **Read `references/auto-delegation-quality-gates.md` in full before acting on it** — the full waiver text is
there. What binds every auto run: the checkpoints stay **visible** (posted in chat as FYIs) and still land in
`.deck-gates.json` (`content.slides`, and `content.checkpoint` / `design_plan.checkpoint` with `mode: auto`);
every Step-0 axis you decided is recorded with `python3 scripts/deck_gates.py picks <deck> --set AXIS=VALUE
--source … [--basis …] [--alternative …]`, and 🔴 **`angle` is never `delegated`**; a delegated **`density` is
balanced (图文均衡)** — only the user can choose text-heavy, and only that choice waives the text budget; a veto posted against any FYI
while the build runs is a **HARD INTERRUPT** (stop, revise the pick and everything downstream of it, re-post,
resume); and the waiver never covers a 🔴 stop that asks for information only the user has. The gates check
the records — the picks through `scripts/delegated_picks.py` on all three gate paths.
**→ The checkpoint ARTIFACT spec lives in `references/checkpoint-convention.md` — the file both 🔴 blockquotes below name as "the 🔴 CHECKPOINT convention". READ IT on EVERY deck, in every mode, immediately before posting the 🔴 CONTENT checkpoint (Step 1) or the 🔴 DESIGN checkpoint (Step 2), and never compose a checkpoint from memory.** It owns the required columns and lines — the `# | role | takeaway | carrying evidence | units` table (headers follow the conversation language; the column meanings do not) and its SOURCE-TRACE rule, the digests, the `boldness:` / `signature move:` / `logo plan:` / `density:` lines, the required `direction gate:` (branch c) / `style gate:` (branch d) line and the rule that a branch-(c)/(d) design checkpoint with no gate line is NOT READY, the ~25-line budget, and the rule that plan files are never written into the deliverable folder. **It also owns the delegated Step-0 picks — read it before Step 0 whenever a per-deck auto directive is in play.**
**Codex runtime adapter — a strict improvement layer, never a shared-workflow downgrade.** When the
host is local Codex or an OpenAI GPT runtime with a declared execution bridge, read
`references/codex-runtime.md` (its Runtime routing section first) before Step 2, then run the evidence
gate before hand-off. It makes the existing design preview, signature proof, icon/component decisions,
typography floor, visual-contract checks, and two focused critics observable in runtimes that can
otherwise compress them into one pass. **Do not run this adapter or reinterpret
`component_audit.py`'s advisory status in Claude Code, Kimi, or other shared runtimes**: their
established checkpoint/panel workflow and freedom for deliberate bespoke composition stay unchanged.
**Codex PPTX routing — HARD RULE (codex profile):** a Codex-verified delivery MUST use this skill's DeckKit
build path and its render, lint, component-audit, visual-contract, critic and delivery-gate artifacts; another
PPTX tool may inspect or convert the file but never replace that path. Full rule: `references/codex-runtime.md`.
## At a glance — pipeline · rule strengths · where things live
*A navigation map only; the steps below are the source of truth.*
**Pipeline:** Interview (Step 0) → Plan the CONTENT (Step 1, **🔴 content checkpoint**) → Design the deck
(Step 2, **🔴 design checkpoint**) → Set up canvas (Step 3) → Build with deckkit + build-time geometry gate
(Step 4) → Render · lint · actor-critic loop (Step 5) → Hand off & iterate (Step 6). Steps run in order;
every **🔴 CHECKPOINT** is a hard stop.
**Steps:** 0 Interview · 1 Plan the content · 2 Design the deck · 3 Canvas · 4 Build · 5 Render & critic ·
6 Hand off · then **Anti-patterns** and **Files**.
**Where commands run.** `SKILL` names the folder that holds this `SKILL.md` (the path the skill was loaded from);
set it once per shell: `export SKILL="/absolute/path/to/slide-maker"`. A command written
`python3 "$SKILL/scripts/…"` runs from any working directory. A command written `python3 scripts/…` means the same
file under `$SKILL`, and runs as written only from inside that folder: from the deck folder, prefix the path with
`"$SKILL/"`.
**Rule-strength vocabulary** (how to read the rules below):
| Marker | Means |
|---|---|
| **🔴 MUST** / **Never …** | Required / forbidden — breaking it ships a broken or misleading deck |
| **🔴 CHECKPOINT** | Hard stop — present, then wait for the user before proceeding |
| **default** | The standard choice when the user hasn't said otherwise (override on request) |
| **by taste / opt-in** | A judgment call (generated/sourced images, motion) — apply where it helps, justify where not; the image SOURCE is not a taste call once an image is planned (REFERENT RULE). Icons are NOT in this class: on category/entity-rich content they are a design must (self-verify (g) · PRE-FLIGHT 12(e)) |
| **carve / exception** | A named case where a rule deliberately yields — follow the carve, don't over-apply it |
> **Changing this skill?** Every 🔴 MUST must be wired into a gate artifact, and removing or merging anything
> needs `references/maintenance-boundaries.md` (in the source repository, https://github.com/addsumtech/slides_maker, not in this package) first — both rules are spelled out there.
**Where things live** — the reference that *owns* each concern (read it when that concern is in play):
| Concern | Owner |
|---|---|
| The craft / the "why" (contrast · hierarchy · C.R.A.P. · layout safety) | `references/design-principles.md` |
| Per-purpose look (defense vs exec vs lecture …) | `references/design-by-purpose.md` — 🔴 four genres (grant · progress/guidance committee · journal club · clinical case) also DECLARE content they are not finished without, checked on both gate paths by `scripts/purposes.py` + `scripts/check_purpose.py` |
| Per-TOPIC look (domain → apt presets → ANTI-PICK + cliché guard — the topic-adapted pick) | `references/design-by-topic.md` — 🔴 it adapts the LOOK only; a domain that needs its own FORM vocabulary is routed on the two rows below |
| Bespoke registers invented from a subject's world (verified library to ADAPT + grow) | `references/bespoke-registers.md` |
| Content — deep read + per-slide message (Step 1) | `agents/content-planner.md` |
| Input formats — Word/Office · image · video (ingest routes + the vision/audio fidelity floor) | `agents/content-planner.md` §1 (Input formats) · `scripts/ingest.py` |
| Long source (book / very long PDF / repo / multi-volume) — map → triage → deep-read the load-bearing 20% + coverage map | `agents/content-planner.md` §1 (long-source mode) · `scripts/extract_pdf.py map`/`text`/`headings` |
| Look / form / layout / rhythm / icons / motion (Step 2) | `agents/slide-design.md` |
| Independent review + JSON schema | `agents/critic.md` · `agents/arbiter.md` · `references/review-rubrics.md` |
| Which visual FORM a slide takes (avoid the card-grid default) | `references/form-selection.md` |
| Colour-means-one-thing (bind a hue to a concept deck-wide) | `references/design-intelligence-addendum.md` §6.1 |
| Style + component catalogue (looks · presets · when to use each) | `references/design-gallery.md` |
| Charts (which type · editable-native vs raster) | `references/data-viz.md` |
| Choropleth map (value per country / province — europe · world · china) | `deckkit.choropleth()` · `scripts/maps.py` · `references/data-viz.md` |
| Science schematics (force / ray / circuit / apparatus …) | `references/schematic-diagrams.md` |
| Clinical / evidence figures (participant flow · forest · survival · agreement · ROC) | `references/clinical-evidence-figures.md` |
| Generated + sourced imagery (when/how · text-free · topical · REFERENT RULE + source tokens) | `references/image-generation.md` |
| Generated-template branch (hero + shallow bg + frosted blocks) | `references/generated-template.md` |
| Icons (one family · recolored · treatments) | `references/icons.md` |
| Mimic a provided style example | `references/style-analysis.md` |
| Fonts / portability / tofu · non-Latin & CJK | `references/font-guidance.md` · `references/multilingual.md` |
| Animation / appear-builds | `references/animation.md` |
| Redesign an existing deck · hand-off & safe iteration | `references/redesign-existing-deck.md` · `references/handoff-and-iteration.md` |
| Cross-deck user taste — registry-root `taste.md` schema · read/write · dial promotion | `references/user-taste.md` |
| Large / sectioned decks · collaborative gates | `references/large-deck-orchestration.md` · `references/collaborative-mode.md` |
| East-Asian / ink looks | `references/east-asian-aesthetic.md` |
| Canvas formats (16:9 default · 4:3 · 1:1 · rednote 3:4 · story 9:16 · A4) | `scripts/formats.py` (registry) · `references/canvas-formats.md` (per-surface layout DNA) |
| A deck you PRESENT FROM — contents page that jumps, backup slides for the questions, the way back | `references/navigation-and-qa.md` (`deckkit.link`/`agenda(targets=)`/`back_link` · the `content.qa` gate) |
| Citing published work — BibTeX in, markers + reference page out, consistency checked | `references/citations-and-bibliography.md` (`scripts/citations.py` · `scripts/check_citations.py`) |
| The build helpers (source of truth) | `scripts/deckkit.py` (docstrings) |
| Geometry lint — build-time · render-time | `deckkit.lint_layout(prs, strict=True)` (Step 4, pre-render) · `scripts/lint_deck.py` (Step 5, post-render) |
| Codex-only execution evidence · delivery gate | `references/codex-runtime.md` · `scripts/codex_delivery_gate.py` |
| What this skill does to the machine — installs, subprocesses, network, session data, file deletion, and every opt-out | `references/security-and-capabilities.md` (read it if a user asks what the skill touches, if a scanner flags it, or before running it on material you do not trust) |
| ANY error / lint finding / env failure — symptom → cause → fix, plain language | `references/troubleshooting-faq.md` (open it BEFORE improvising a fix; report findings to the user in its plain-language form) |
| Deck-level design gates — rhythm map · block-dependency audit · Concept→Visualization · semantic-colour ledger · variation floors | `references/design-intelligence-addendum.md` (Step 2's measured design targets) |
The table above routes by *concern*. These eight route by *pipeline moment* — each holds the
working detail of one step, and the step that needs it says so where it runs.
**What is NOT here, and why.** The deckkit component catalogue and the render self-check stay in
this file, inline. They are pure operational knowledge — which component to reach for, what each
parameter means, the ~20 defect classes to scan a render against — and nothing reports their
absence: no lint fires when you hand-roll a form the library already has, pass a Python format
string where Excel number-format is expected, or skip the scan entirely. A rule whose omission is
*silent* cannot live behind a read. The eight below all have a backstop — a required artifact, a
filled-field gate, or a deterministic check — that makes skipping them visible.
| Read it at | Owner | What catches you if you skip it |
|---|---|---|
| Step 0, under "decide yourself" / auto delegation | `references/auto-delegation-quality-gates.md` | the delegated-picks recap in the hand-off note (`handoff-checklist.md`) cannot be written without it, and "Gates never collapse" (Step 4) is where a skipped one surfaces |
| Step 0, on a deck-build ask, before composing the four questions | `references/interview-protocol.md` | the Step-0 picks FYI can't be written without it |
| Step 1, before writing the comprehension brief | `references/content-plan-spec.md` | the comprehension gate rejects an unfilled brief |
| End of Step 1 and Step 2, before posting either 🔴 checkpoint | `references/checkpoint-convention.md` | the checkpoint artifact is the thing it specifies |
| Step 2, once the plan is approved and any asset is named | `references/asset-production.md` | PRE-FLIGHT 4 (charts) · 5 (evidence) · 12(e) (icons) |
| Step 3, on a non-16:9 surface or a supplied template | `references/deck-setup.md` | on a **CJK** deck, `CJK_NO_EA` fails the build on a missing EA font — that is this file's Fonts section, and it is the only gate that fires on its own. The **non-16:9** and **template** branches have no gate of their own: `lint_layout` reads the real canvas size, so a 16:9 layout transplanted onto a portrait canvas trips `OFF_CANVAS`, but nothing checks a format's **safe band** (`formats.py band()`), its `lint_flags`, or the design plan's `format:` line. What actually holds them is upstream and human: Step 0 **confirms the canvas format** for any non-slide surface (`interview-protocol.md`), and the answer rides into the Step-0 picks FYI. Read the file |
| Step 5, at every critic dispatch and returned review | `references/critic-panel.md` | `validate_review.py` rejects a non-conforming review — but it checks the review CONTRACT only. Panel size, lens assignment and the arbiter pass have **no** check; Step 5's dispatch names this file for them |
| Step 6, before composing the hand-off — every deck | `references/handoff-checklist.md` | the hand-off note is itself the visible artifact |
| A helper's exact call contract, before writing build code | `scripts/sigs.py <names…>` (one lookup, many helpers; `--example` for a runnable call) | **nothing** — `sigs.py` is a PULL tool with no gate. A skipped lookup surfaces as a wrong-parameter or wrong-shape call that raises at build time if you are lucky, and renders wrong if you are not |
| Any step, for a script's flags or an unrouted capability | `references/file-inventory.md` | lookup only — nothing depends on having read it |
*(Full file/script inventory: see **Files** at the end.)*
## Step 0 — Interview the user first (always)
> **Scope guard — the build interview fires for DECK-BUILDING asks only** (make/redesign/improve a
> deck or slide). A request to *audit or review this skill/repo*, *critique an existing deck without
> rebuilding it*, *extract/crop figures*, or *answer a question* is NOT a build — do that task
> directly; running the four-question interview there is noise. When in doubt ("improve my deck"
> could be either), one clarifying line beats a wrong assumption.
### Step 0.0 — INITIALIZE: the version choice, before anything is asked
🔴 **This runs FIRST on ANY invocation, build or not — before the capability ledger, before the
four questions, before you read a single byte of their material.** (The scope guard above skips the
*interview* for a critique/audit ask; it does not skip this — a stale skill reviews a deck by stale
rules.) `python3 scripts/check_version.py` is silent when the install is
current, and then you say nothing and go straight to the interview. Cost is one network call at most
per 24h (~0.1s from cache otherwise), and every failure path — offline, no marker, corrupt cache —
exits silently, so it can never be the reason a deck did not get built. It lives in Step 0 rather
than in a reference because a check nobody triggers is a check that does not exist. Opt out with
`SLIDE_MAKER_NO_VERSION_CHECK=1`.
🔴 **When it reports an update (or `DIFFERS … at the same version`), read `references/troubleshooting-faq.md`
BEFORE replying.** It holds the three options to ASK as the first thing in the conversation (spell out what
each answer does; under a per-deck AUTO WAIVER do not stop — build on the installed version and say so), the
per-`shape` update command (never `npx skills add` on a plugin install), the rule to re-read SKILL.md after an
update, and why `dirty: null` means *unknown*, never "no local changes".
### Step 0.0b — ENSURE THE TOOLCHAIN, right after the version is settled (build asks only)
🔴 **Before the interview, on a deck-BUILD ask, run `python3 scripts/check_env.py --ensure`.** It is silent
when everything is present and installs missing pip deps itself. Act on the exit code: **`0`** go on; **`3`**
LibreOffice is missing — show the user the install command it printed NOW (the render needs it); **`1`** a pip
dep could not be installed — show the printed command, and never add `--break-system-packages` for them.
Skip it on a critique/question run. Details: `references/troubleshooting-faq.md`.
**Run this interview every time, from scratch — do not skip it because earlier
conversation, a previous deck, or context "obviously" implies an answer.** A terse
request like *"make slides for MICCAI"* specifies only one thing (the venue);
the content, source material, style, and template are all still unknown and must be
**collected, not assumed**. The biggest failure mode is silently carrying over
assumptions from a prior deck in the same session (its topic, its content, its
style, its template) — every deck starts fresh with these questions.
Collect all the answers in **one cheap interview turn**. Match the host UI:
- **If the runtime provides a structured choice UI** (for example Claude Code's
`AskUserQuestion`), ask the questions in one batched call with concise options.
- **If the runtime does not provide that UI** — plain Codex chat, a GPT/Gemini/Kimi chat surface,
an API caller, a CLI with no widgets: **the norm, not the exception** — ask one compact direct
question and let the user answer in free text. Do not fabricate a fake multiple-choice form;
give short examples only where they reduce ambiguity.
🔴 **Fewer WIDGETS, never fewer QUESTIONS.** A choice UI carries the axes for you — every option
the host renders is one you cannot forget to ask. In plain text nothing carries them, so the
axes that vanish are exactly the ones with no downstream artifact demanding them: **deck length**
first (measured: decks arriving at ONE page), then delivery mode. Ask all
five numbered lines below; a host without widgets is not a host with a shorter interview.
🔴 **Ask in the USER's language.** The fallback block is written in English because this file is;
a user writing Chinese gets the same five questions in Chinese. Translating the questions is not
personalisation, it is the baseline — and it costs one pass over a block you are already typing.
Direct-question fallback:
```text
Before I build, please give me:
1. Template/brand: existing template, new template, design a clean one, or generate one with an image tool?
2. Purpose/audience/time: who is this for, how long — and is it presented live, screen-shared, sent to self-read, or presented live THEN sent around (hybrid: presented density on-slide, self-sufficient speaker notes)? Main goal: inform, support a decision, or inspire action? — If decide/inspire, one cheap follow-up: what exactly is the ASK, who says yes, and what's the biggest objection you expect? (Duarte's briefing trio; it sharpens the money slide and the close.)
3. Source material: paper, deck, doc, figures, repo, or none? — When material IS provided, one follow-up: condense freely, preserve key phrasing verbatim, or hybrid (verbatim for claims/numbers, condense elsewhere)? Record the answer; it governs every rewrite downstream.
4. HOW MANY SLIDES: a spoken deck takes it from the time budget (~1 slide/minute); a self-read one
needs it said — short ~5-8, medium ~9-15, long 16+. Never assume, and never take silence as ONE.
5. Style/language: density (≈a phrase / one sentence / 2–3 sentences per point?), tone (minimal/corporate/academic/playful), and language (Chinese/English/etc.)?
```
*(No review question here — it is asked at Step 5, AFTER the first clean render, with the deck in
front of the user. Asking it blind at Step 0 forced a cost decision about a deck nobody had seen.)*
🔴 **Q1 answered "our brand" — a company / lab / product deck, with a logo, a brand-guide PDF, an old on-brand .pptx, or just hex codes and font names?** Do not hand-build a .potx and never guess a brand's colours from its name. `python3 scripts/brand_kit.py extract <files…> [--hex #RRGGBB …] [--font "Name" …] --out <deck-dir>/brand.json`, then `brand_kit.py review <deck-dir>/brand.json` — show the user its table (auto mode: `--auto`, and record the delegated pick it prints) — then `brand_kit.py confirm … --primary … --accent … --neutral …` with THEIR roles. Every command prints its `NEXT:`. A brand used before needs none of it: `brand_kit.py list` · `use <name> <deck-dir>`; save a new one at hand-off with `save <brand.json> --name <name>`.
Only a website to go on? OFFER to read it and run it only on a yes, never on your own (auto mode included): it downloads a third-party npm package and opens a live site. With Node 22+ and a Chrome-family browser, `npx [email protected] <url> --no-stores --out <deck-dir>/brand-src` opens the site in a headless Chrome on the user's machine and saves its logo files, with the colours by where the site uses them and the fonts listed in `brand-src/BRAND.md`. Pass a logo file from there (the `.svg` when there is one) to `extract`, the button and heading colours as `--hex` and the fonts as `--font`. The version is pinned on purpose: never swap in `@latest` — a new release reaches users only through a reviewed change here. A no, no Node, no browser or a failed run: ask for the logo file, hex codes and font names instead.
🔴 **On a host with NO choice UI — the norm, not the exception — one command carries the axes for you.** `python3 scripts/deck_gates.py interview <deck-dir> --lang en|zh` prints the four questions in the USER's language (this file's fallback block is English because this file is; the command carries Chinese too, so "ask in their language" stops being an instruction whose only example contradicts it), and `… interview <deck-dir> --set language=… --set density=… --set length=… --set goal=…` records them. With no `--set` it lists what is still unanswered and exits 1, so it is also the pre-flight. A plain-chat runtime has nothing carrying these axes — a widget carries them for a host that has one — which is why this is a command and not a paragraph.
🔴 **A choice UI takes FOUR questions per call and this interview has FIVE lines — so "one batched
call" silently truncates the last one, which is the line LANGUAGE lives on.** Measured in this
repo's own session: a real deck was built and language was never asked, while the record carried
`delivery`, `builds` and `content.slides` — the three axes something downstream demanded — and no
answer for language, density, length or goal. Send **two calls** (four, then the rest); a host with
widgets does not get a shorter interview. 🔴 **And RECORD the answers**: `interview.language`,
`.density`, `.length` and `.goal` are required by `--gate-check` and by the codex gate, from one
shared axis list (`deck_gates.INTERVIEW_AXES`), and `deck_gates.py --init` scaffolds them. Those
four are singled out because nothing else demands them — which is exactly why they are the ones
that go unasked. The waiver is written (`{"interview": {"waived": "<why>"}}`), and under the auto
directive these are your delegated picks: the waiver removes the STOP, never the record.
🔴 **A missing answer is a QUESTION, never a default — and least of all a one-slide default.** If
the user names no length and no time budget, ask; if they decline to answer, derive it from the
CONTENT (how many takeaways the material actually supports) and say the number in the plan before
building. A deck silently built at one page is not a small deck, it is an unasked question.
This batching is deliberate: the interview is non-negotiable, so it has to be *cheap*.
Only drop a question if the user already answered *that* one in their current request — or the
deck runs under a full per-deck auto directive, where you answer the preference questions by
delegation and post the picks as the first FYI (see **the per-deck AUTO WAIVER**; the topic /
source-material floor still gets asked);
when in doubt, keep it. Never assume the **topic/content**, the **style**, or **which
template** — confirm each.
🔴 **Hand-off checks that bind when their record exists** — each runs on both gate paths; the full rules are in
`references/troubleshooting-faq.md`. Record the field whenever it applies:
- **Purpose sections** — 12 of the 13 purposes declare required content (e.g. defense: contributions ·
limitations · future work); `check_purpose.py` looks for it in the built deck (extend with
`design_plan.purpose_section_terms`).
- **A talk has a slot** — record `content.talk_minutes`; `check_talk_time.py` holds the speaker notes to it.
- **Presented live where the room can interrupt** (defense, committee, conference, board) → read
`references/navigation-and-qa.md`; record `content.qa`.
- **Cites published work** → read `references/citations-and-bibliography.md`; cite from the .bib via
`scripts/citations.py`, never from memory; record `content.citations`.
- Every gate run ends with a **COVERAGE** line — read it: PASSED is not CHECKED.
- `--deliverables` exports an accessible PDF and a speaker-notes handout.
**The `review:` question is NOT asked here — it moved to Step 5, after the first clean render.**
It used to be a Step-0 axis, which forced the user to size a review of a deck nobody had seen;
with the rendered deck in front of them the same choice is informed instead of blind, and that is
what makes the cheaper default safe (Step 5 owns the question, its four options and the recording
rules). What Step 0 STILL decides is the **research breadth**, because research happens before
anything renders and cannot wait for the post-build question: derive it from the purpose —
`standard` for a lab meeting / status update / teaching deck, `thorough` for a defense /
conference talk / exec readout / pitch (the same two stakes classes the skill has always had;
purpose decides, deck SIZE never lowers it) — state the derived value in the Step-0 picks/plan,
and hand it to the planner at Step 1. Research narrows BREADTH only, never the fidelity floor:
every claim that reaches a slide is traced to a primary source at every breadth.
**🔴 Read `references/interview-protocol.md` before you ask anything on a build ask** — it owns the rest of Step 0: two-stage personalization from THIS user's footprint + `taste.md` precedence (🔴 MUST: current request > this interview's answers > `taste.md`), scaling the interview to the ask, Q1's four template choices (a)–(d) — all four MUST be offered, never a hardcoded institution — with each branch, Q2's delivery · deck-length · appear-builds · primary-goal axes + per-purpose cases + venue research, and Q3's source-material routing per input format.
> **One 🔴 CHECKPOINT lives in that file:** the Q1(d) generated-template **hero checkpoint** (show the hero + a sample content slide, iterate until the user confirms). The Q1(c) **direction gate** (4 rendered directions) RUNS BY DEFAULT on the design-a-clean-one branch — skippable only via its named carves, and recorded on the design checkpoint's `direction gate:` line.
- **Their own deck, to *improve*** (e.g. "redesign this", "my slides are too
dense", "make my deck better") → this is a redesign, not a build-from-scratch, and
it rewards a different front end. **Follow `references/redesign-existing-deck.md`**:
ask two extra answers in the same interview turn — *keep your
design/branding, or redesign the look?* and *how deep — light cleanup keeping your
structure, or full re-author?* — **these REPLACE the Q1 template question** (the R0 rule in
`references/redesign-existing-deck.md`): *keep* makes their deck the template; *redesign the
look* triggers Q1's four choices as a post-batch follow-up — and **diagnose their deck first** (render it,
extract its content/figures with `scripts/extract_deck.py`, run the critic on it),
then show the weakness list and confirm scope **before** rebuilding. Optimizing
someone's existing deck rewards a diagnosis-led, scope-confirmed approach over a
silent ground-up replacement.
> **🔴 CHECKPOINT** — show the diagnosis + proposed scope and get the user's OK before rebuilding their deck.
**Q4 (style) — density levels, mimic modes, and the direction-gate scope are in `references/interview-protocol.md` (same file, later section). Read it before you offer the style question.** It owns the three DENSITY levels (diagram-heavy / balanced / text-heavy, defined by text-per-point) and the mimic-a-style-example modes — two user choices that exist ONLY here, so if th原文較長,這裡只顯示前 40 KB,完整內容請到來源頁面檢視。
透過 MCP 在騰訊文件裡新建、編輯與管理線上文件的完整操作手冊。
WPS Office 全家桶 - 四引擎(WPS/MS Office/LibreOffice/純Python)智慧識別使用者已安裝軟體,純Python模式支援排序/篩選/圖表/公式/統計,含文件模板(程式碼生成)、最佳實踐案例、故障排除大章(20+避坑+15 FAQ+15錯誤ID 統一索引)、自動重試、硬體自適應、環境自檢、Skill更新提醒;v5.1新增:kingdoc雲端橋接(白名單探測+配置預檢+subprocess上傳+差異檢查)、條件格式/資料驗證跨引擎IO(JSON中間格式保真往返)、會議紀要三段式要素化(待辦清單+決策記錄+風險異議)+說話人標註(MFCC聚類);v5.2新增:公文一鍵排版(GB/T 9704 規則庫約束+結構識別套版+紅頭預留位+聯合行文)、批次水印與敏感資訊打碼(身份證/手機號/銀行卡/電子郵件雙軌識別+黑色矩形覆蓋+打碼清單)、跨文件知識檢索與問答(本地TF-IDF零依賴+跳轉+可選zwjh記憶橋接);刪除:與contract-review重複的輕量合同審查模組,改為文件互鏈引導;v5.2.5修復:MS Office引擎下Excel/PPT建立必然失敗(錯用Word COM物件),新增get_ms_excel/get_ms_ppt及三槽位統一釋放release_ms,MS Office路徑透傳filepath引數;v5.3.5修復:SKILL.md frontmatter 修復 tags 塊序列誤混入聯絡方式行導致標準 YAML 解析失敗;v5.4.0新增:留存型功能——定時任務與報告中心(schedule_register 升級為三平台統一排程層 schtasks/cron/launchd,錯過策略 skip/run_once,登錄檔 JSON 可匯出匯入;新建 report_center.py 報告中心,templates/reports/*.json 引數化模板 + ECharts 單檔案 HTML 輸出(圖表內聯、無服務端、雙擊即開);report_generator 升級支援 --format html;wps.py CLI 統一埋點 SQLite,自動供 report_center 生成周度使用摘要附在報告末尾;watch.py 職責收窄為純事件採集);v5.3.0新增:統一CLI入口 wps(registry.json登錄檔分發,office --app/--action 與 convert 子命令、--list 一屏列出全部命令,薄路由層不改指令碼內部邏輯)、全命令 --json 機器可讀輸出(固定 ok/error_id/elapsed/data 四欄位,對齊 E001-E015,wps_error.py 新增 emit_json 統一齣口)、_worker 啟動最佳化(wps_pure 改惰性載入,pywin32/python-docx/openpyxl 經核查已惰性匯入,ENGINE_CACHE 程序級單例複用,COM 釋放統一走 release_ms 三槽位)、轉換三入口合併為 convert(format_converter/md_converter/wps_docx_to_ppt 內部按目標格式路由,舊指令碼保留為相容別名並提示新命令,v6.0.0 移除)
按主題與風格自動生成 PPT 檔案的技能。
體制內資深辦公室主任+管理學博士,自學程式設計開發的智慧公文寫作Skill,讓所有辦公室同仁少掉頭髮、少加無用的班,材料一稿過關,省下的時間留給自己、享受生活!————————我們能給你帶來的核心價值:1、顛覆傳統寫作:邏輯建模38類公文全鏈條,特有模板化引導問答模式,分分鐘省心生成高質量大稿。--------2、替你“向上管理”:獨有審稿人畫像機制,文稿一鍵結構性修改,精準匹配審稿人畫像,過稿率提升至少10倍!----------3、杜絕AI編造:缺失的數字、文號、人名、日期一律用[待補]標註,絕不杜撰,守住公文底線。-----------4、演算法格式托底:數十萬全量智控知識庫+6500行前沿核心控制程式碼,格式精準對齊GB/T 9704,出稿零失誤。——————————————————本skill歷史版本開放了5%知識庫的免費試用版,下載即可使用,但需注意:知識庫有著作權,僅用於個人使用,不可用於其他任何目的。有興趣的可以試試。——————————————————————單次付費版skill已釋出,2元一次使用全量知識庫。具體在釋出者“熵衍資訊”主頁skill裡。
WPS Office 全家桶 - 四引擎(WPS/MS Office/LibreOffice/純Python)智慧識別使用者已安裝軟體,純Python模式支援排序/篩選/圖表/公式/統計,含文件模板(程式碼生成)、最佳實踐案例、故障排除大章(20+避坑+15 FAQ+15錯誤ID 統一索引)、自動重試、硬體自適應、環境自檢、Skill更新提醒;v5.0新增:定時任務註冊管理(schtasks/crontab)、目錄輪詢監聽(YAML規則+大檔案分片)、使用統計與穩定性中心(SQLite埋點+引擎健康+引擎偏好)、COM三步自愈(regsvr32→修復安裝→手動指引)、對話式資料查詢(NL2SQL式意圖解析+查詢計劃+連續追問)、multi-agent編排引擎橋接(白名單探測+流水線模板註冊)
當用戶要處理 Word/Excel/PPT、做文件模板與排版、批次合併圖表、公文一鍵套紅頭、會議紀要要素化、或跨引擎辦公自動化時,WPS全家桶·辦公管家.Skill 立即出動。 四引擎智慧識別已裝軟體(WPS/MS Office/LibreOffice/純Python),純Python模式支援排序/篩選/圖表/公式/統計;含文件模板程式碼生成、20+避坑+15 FAQ+15錯誤ID統一索引、自動重試、硬體自適應、環境自檢。 當用戶提到批次水印、敏感資訊打碼(身份證/手機號/銀行卡/電子郵件)、跨文件檢索問答等訊號時,主動亮劍。
透過 Tencent Docs Open API 以 curl + jq 建立、讀取、列出、搜尋和管理騰訊文件的自動化工作流,覆蓋線上文件、線上表格、幻燈片、思維導圖、流程圖、智慧表格與收集表七種類型,支援讀取後設資料與單元格區域、上傳圖片、建立副本,並對重新命名/移動/刪除等寫操作強制先經使用者確認。Use when the user 提到騰訊文件 / Tencent Docs / docs.qq.com、貼上 docs.qq.com 連結,或想在其騰訊文件空間中建立、讀取、整理文件時使用。Triggers include 騰訊文件、線上文件、線上表格、思維導圖、流程圖、智慧表格、收集表。如需文案寫作完整工作流套件,淘寶搜尋「AI靈匣」店鋪獲取完整版。
透過 kdocs-cli 操作金山文件雲文件的官方技能。
資料月份:2026-10 · 下載/星標數聚合自公開技能註冊庫(ClawHub、SkillHub),按月更新。口徑說明見資料方法。