Agent skill

Pneuma Bansho

by pandazki in pandazki/pneuma-skills

Explain something by writing it on a board. An agent skill from pandazki/pneuma-skills.

MITAuto-check passedMedia & Creative

Install Pneuma Bansho

skills CLI
$ npx skills add pandazki/pneuma-skills --skill pneuma-bansho -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install pandazki/pneuma-skills pneuma-bansho --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/pandazki/pneuma-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/modes/bansho/skill .claude/skills/pneuma-bansho && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
pneuma-bansho
GitHub stars
161
Token cost
~6.9k tokens
SKILL.md length
4,145 words
Files
9 (incl. scripts, references)
Skills in repo
30
Repo updated
First seen
Licence
MIT

At a glance

Explain something by writing it on a board. An agent skill from pandazki/pneuma-skills.

  • Works in 6 steps: Set the stage — 铺垫 → Emphasize — 强调 → Contrast — 对比 → …
  • ANY task in this workspace — writing
  • SKILL.md covers How the board reads your writing, The room, the camera and the…, Placing — @at and Before the first word — design…, plus 7 more sections
  • Runs JavaScript scripts from its folder

What it does

Pneuma Bansho is an agent skill from pandazki/pneuma-skills. Explain something by writing it on a board. Use for ANY task in this workspace — writing or extending board.md, correcting or re-explaining a stretch of the lecture, giving it a voice, exporting subtitles, restyling theme.css. Trigger whenever the user wants a thing explained rather than documented — in Chinese (板书 / 讲一讲) or English ("explain this on a whiteboard", "teach me X") — and whenever they point at a step on the board and ask about it.

Its SKILL.md is about 6.9k tokens, which your agent loads only when the skill is triggered. The skill folder holds 10 other files, including scripts and reference files (for example `references/board-language.md`, `references/charts.md` and `references/illustrations.md`).

It sits in Media & Creative, covering Tutoring and explanations and Transcription. The repository describes itself as: Co-creation infrastructure for humans and code agents — visual environment, skills, continuous learning, and distribution. The licence is MIT.

When your agent uses it

  • ANY task in this workspace — writing
  • Extending board.md
  • Re-explaining a stretch of the lecture
  • Giving it a voice

Example prompts

  • “explain this on a whiteboard”
  • “teach me X”
  • “/pneuma-bansho”

Requirements

  • Node.js

Workflow steps

6 steps, taken from the step headings in SKILL.md.

  1. Set the stage — 铺垫
  2. Emphasize — 强调
  3. Contrast — 对比
  4. Correct — 修正
  5. Give evidence — 给证据
  6. Close — 收束

What it can do on your machine

Read from SKILL.md and the folder at commit 0023d3c. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 1 file in scripts/ (JavaScript), which the agent can run.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Pneuma Bansho loads about 6.9k tokens when it runs, and up to ~27k if it reads all its reference files. Until then it costs about 117 tokens; SKILL.md has 4,145 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~117
When it runs · the whole SKILL.md, loaded when a task matches
~6.9k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~27k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from pandazki/pneuma-skills at commit 0023d3c, republished under its MIT licence (© pandazki). 4,145 words, ~6,945 tokens.

Download SKILL.mdSave it as .claude/skills/pneuma-bansho/SKILL.md (or your agent's skills folder). This skill also uses 8 other files; get the full folder from GitHub.
name
pneuma-bansho
description
Explain something by writing it on a board. Use for ANY task in this workspace — writing or extending `board.md`, correcting or re-explaining a stretch of the lecture, giving it a voice, exporting subtitles, restyling `theme.css`. Trigger whenever the user wants a thing explained rather than documented — in Chinese (板书 / 讲一讲) or English ("explain this on a whiteboard", "teach me X") — and whenever they point at a step on the board and ask about it.

Bansho — board-writing explainer

板上只有一支笔。你写下的每一件事都会等前一件事收笔。 — one pen on the board; everything you write waits for the previous thing to finish.

You are at a board with something to explain. You write the lecture — plain structured markdown in board.md — and the board performs it: handwriting flows in, your emphasis marks become hand-drawn ink, your charts draw themselves as the talk reaches them. The user watches live, scrubs back through time, and points at steps to ask about them.

Nothing here asks you to pick effects or manage timing — the board derives all of that from what you wrote and how you punctuated it. If board.md reads well as an essay, it plays well as a lecture.

Write in performance rhythm: look up (glance-board), decide where the writing lands and say it (@at), append one or two blocks, let them play, then compare — the tail past the playhead is still free to rewrite. Every save streams straight onto the user's board; one giant write compresses a live talk into a poster.

How the board reads your writing

Plain markdown IS the dialect: each block is one step of the talk, and the marks you would write anyway are the pen's instructions. The six highest-frequency forms:

You writeOn the board
# 标题 / ## 小节written large, hand-drawn underline, then a longer breath
a paragraphhandwriting flows in; commas and periods carry their own pauses
- 条目a hand-drawn dot per item, one item at a time
==三倍== / **结构性** / ((35.6B))ink — the sentence is written first, then the pen returns: marker sweep / underline / circle
~~常规反弹~~write it wrong on purpose: written, a pause, struck through — crossed out, never erased
```chart 名字 / ```graph 名字evidence — axes then one line at a time; boxes and arrows one at a time

Turning back to earlier writing is its own line — the pen goes back to the nearest earlier exact match of the quoted text and inks it:

markdown
@strike "慢了就加机器"

@circle "…", @highlight "…" and @underline "…" work the same way. If the quote is ambiguous, quote a longer run. A quote matching nothing draws no ink: an "unreadable block" badge stands in, plus a refUnresolved warning. @wait (or @wait 2, in seconds) adds one extra breath — the dialect's only timing word. The full grammar — asides, ---, $…$ mathematics, aligned pairs, every pairing — is in references/board-language.md.

The room, the camera and the eraser

@board 3 — the very first line of board.md, before even the title — stands 2–4 boards side by side instead of the single long strip. The lecture fills them in order and the camera walks with the pen. The room never erases anything: a full board sends writing to a blank one, and a full WALL leaves the pen where it is, running past the bottom edge — visibly, and the self-check says how far. Retiring is yours to say. @board anywhere else is a broken step, and no verb takes a board number.

The camera takes direction — two verbs, each standing alone as a line:

markdown
@focus "并行的天花板"

@overview

@focus walks the view back to that text — "let me take you to look at this" — at reading size, never magnified. @overview steps back until everything written so far is in view. A directed view holds while you pause or erase, and returns to the pen the moment writing resumes. The camera already follows the pen on its own — direct it at the turns of the argument, not per step.

Erasing is a move of its own — "this served its purpose, put it down":

markdown
@erase
@erase "并行的天花板"

Bare @erase clears the board under the pen; the quoted form takes back what stands around that earlier text — and the text you name has to be on the board the pen is on. Three conditions, all three or none: the pen's own board, content the talk is finished with, and a sentence that says so. Running short of room is not one of them: "I need space" reaches for the nearest earlier quote and retires a board the audience was still reading. Strike negates in view; erase retires without judgment; scrubbing back always re-shows it.

@turn — the word written too early more than any other: "there is no room left here." Strike negates, erase retires, turn leaves a FULL board standing; a full wall refuses (turnOnFullWall). A face fills in COLUMNS — writing carries on at the top of the next column — so the room already turns for you, a heading needs no turn, and an early one is said back (turnUnderfilled). Fill the face first — @at puts the next block BESIDE what stands.

Placing — @at

A board is a surface, not a column. @at right — a line of its own, like @erase — walks the pen to a named part of the board under it, and everything after it lands there until the next @at / @turn / the end.

The words are all there are — full · left · right · top · bottom and the four corners on a wall of boards; only full / left / right on the strip (no bottom, so no halves). No pixels, no percentages, no board numbers: the word says how wide and which edge, and @at full returns to the room's flow. The quoted form walks to the region holding that earlier text — how you go back to a column you left half-written, and how you set two columns against each other (@at left for A, then @at right "A 的开 头", top-aligned with it); on the strip a bare @at opens a NEW placement at the write front every time. "Figure right, prose left" is three declarations (@at left · @at right · @at left), because full always writes BELOW everything standing; "a definition parked in a corner" is one, then @at full and carry on. Nothing is repaired for you: a region's size is a budget, not a wall — overfill it and the writing runs past the space it was given, where it stands, and whatever passes the BOARD's bottom edge is not written at all (regionBurst — answer it, do not write on: say less, take a word with more room, or @turn for a board of its own); two declarations may land on each other and both are written, later ink over earlier (regionCollision). Place because the content asks — a placement for decoration is as bad as a sentence written for geometry.

A full title then @at left puts the column ON the title: only full writes below what stands. Full grammar: references/board-language.md.

Before the first word — design the lecture

A lecture written straight into prose is written well sentence by sentence and never designed. Every passage becomes a paragraph, because a paragraph is what prose makes; nothing gets drawn, because a figure has to be chosen BEFORE the sentences exist — afterwards everything already looks like prose. A real lecture written this way came out as four half-filled faces with zero figures, though its central idea was a picture. Nobody chose that. It is what happens when there is no design.

So the first move is not a move on the board. Write the design down in plan.md, beside board.md in the content set — not inside board.md, where everything is performed and a design would be handwritten onto the board in front of the user. A file survives what your memory does not, the user can read it, and no board step is written before it exists. It holds the arc, and then three decisions PER PASSAGE:

  • The arc — the question the board opens on, the payoff it closes on, and the handful of passages between. Three to six is a lecture; a dozen is a syllabus.
  • MEDIUM — prose · figure · formula · worked example. A passage that counts, compares, splits, or traces a flow is a picture; one that names or concludes is words. A lecture whose central idea is a picture and which draws none has not been designed.
  • ROOM — which board, and how much of it. A face fills in COLUMNS, so a wall of four boards is EIGHT columns; a design that never says so writes four and leaves four blank. Name it in @at words (left · right · full), never in sizes.
  • LENGTH — roughly how many seconds. The board reports what each passage really takes; the estimate is what lets you notice you are 60 seconds into a ten-minute lecture.
markdown
# 为什么加机器不一定更快 — plan   @board 3 · ~6 min

Q 加一倍机器,为什么不快一倍?   A 串行的那一段就是天花板。

| # | 内容 | medium | room | len |
|---|---|---|---|---|
| 1 | 把口头禅立在板上 | prose | b1 `@at left` | ~40s |
| 2 | 三人搬砖、一人签字 | FIGURE t1 | b1 `@at right` | ~60s |
| 3 | 阿姆达尔定律 | formula | b2 `@at full` | ~50s |
| 4 | 1% 串行 → 100 倍上限 | FIGURE t1 | b2 `@at right` | ~70s |
| 5 | 收束:先去找那一段 | prose | b3 `@at full` | ~40s |

A figure also gets a tier, in the same table. Almost every picture is the board's own — chart, graph, ink on the words — and the board genuinely draws it, one line at a time, in front of the user: that is tier 1, and it is the answer whenever the passage counts, compares, splits or traces a flow. A few pictures need real hand-drawing ability (a neuron, a cross-section, a thing whose likeness is the point): that is tier 2, ordered from an outside hand in one command. You never write the look — the skill owns it, you fill in the subject.

The rule is one line, so it costs nothing at the table: sayable with chart / graph / ink → tier 1; needs a real hand → tier 2. Then every tier-2 picture is ordered in ONE batch the moment the plan is settled, before the first board step — never mid-lecture, because each is real money and the better part of a minute, and a wait spent in the middle of a live talk is paid by the audience. Batched, the pictures are on disk before the pen wants them and the writing carries nothing extra. With no key there is no tier 2: say so in plan.md and fall back to tier 1, or drop the figure and tell the user. Never fake one.

Then one passage at a time: write it → let it play → glance-board → hold what stands against the design → next. Two passages behind a glance is already flying blind. The design is a promise and reality gets a vote: when a passage runs long, a figure turns out to be one sentence, or a board fills two passages early, edit plan.md and say in one line what changed and why. That is a teacher adjusting. A design silently abandoned mid-lecture is the failure this move exists to prevent, and it is invisible from the inside — every individual sentence still reads fine.

If you have a Workflow tool, plan-lecture runs exactly this as a procedure: rival arcs judged against each other, the design written, then critiqued for missing pictures and unused columns, all before one board step exists — the same work, in an order you cannot skip. Without it these words are the whole instrument and you run it yourself. Depth — sizing a passage, telling a figure from a paragraph in a box, revising honestly — is in references/lecture-plan.md.

The six moves

Everything you do on a board is one of six moves. Each is a single held pen — no move overlaps another.

1. Set the stage — 铺垫

Give the board a question before you give it answers. Title, one opening paragraph, then the first section:

markdown
# 为什么加机器不一定更快

这块板要说清一件事:并行是有天花板的,而且天花板比大多数人以为的低。

## 先把那句口头禅立在这里

The title is written large and underlined by hand; the section heading turns the page. Everything that follows lands on a board already asking something.

2. Emphasize — 强调

Mark the few words that carry the sentence — after the sentence has been written, the pen comes back for them:

markdown
把机器数记作 $n$,口头禅的意思是:==加一倍机器,快一倍==。

真实的上限是 ((20 倍)),**不是无穷**。

One heavy mark per sentence. A board covered in marker has no emphasis left — if everything shouts, nothing does.

3. Contrast — 对比

Contrast comes from placement, never simultaneity. Parallel claims go in a list; consecutive items sharing one separator (: or —) align into two columns like a teacher tabulating:

markdown
- 频率:每月一次 → 每天多次
- 批量:一百多个改动 → 一两个
- 回滚:整包退回 → 只退那一个

Two trends contrast by sharing one chart — and the second line starts only after the first has fully arrived, so the audience holds the finished line in mind while the contender is drawn against it. The layered evidence in move 5 below is the same shape; pacing craft lives in references/charts.md.

4. Correct — 修正

Write the mistake, then kill it in view. Never delete it — the crossed-out wrong answer is content; the audience learns from watching it die.

In place — you knew it was wrong when you wrote it, setup and correction in one breath:

markdown
~~这只是一次常规的周期性反弹~~ —— 这是**结构性**的需求转移。

Turning back — the argument had to advance before the claim could fall. State it, argue past it, then send the pen back:

markdown
错的不是结论,是它藏着的两个前提:((串行段为零)),((协调不要钱))。

@strike "慢了就加机器"
5. Give evidence — 给证据

The sentence states the claim; the block right after it draws the proof. Axes stand first (a teacher ruling the board before any data), then each layer arrives with the sentence that explains it — one per sentence:

markdown
我们把两家公司的营收放到同一张图上:

```chart revenue
x: 2023Q1 .. 2024Q4  (季度)
y: 0 .. 40  (十亿美元)
```

先看英伟达——每个季度都在加速:

```chart revenue
+ NVIDIA: 7.2 10.3 14.5 18.4 22.6 26.0 30.8 35.6
```

差距的终点停在这里:

```chart revenue
+ mark NVIDIA @ 2024Q4 : "35.6B"
```

The chart stays where first declared; later same-name blocks draw into the same picture while your text continues below. Structure is evidence too:

markdown
```graph 数据流
讲稿 → 推断 → 时间轴 → 播放
推断: 把讲稿变成串行 step
```

Chains draw boxes and arrows in reading order; 名字: 说明 writes an explanation into a box; naming a node again draws nothing — it is already on the board. Layout is computed; you never place boxes. Formulas are evidence too: $S(n) = \frac{1}{(1-p) + p/n}$ inline or $$…$$ as a block.

A figure's SIZE is the one thing about it you cannot read back from the file. chart and graph take their proportions from their own contents, not from the handwriting beside them, so a flow chart in a narrow column comes out at a third the size of the words around it while the markdown reads perfectly — and nothing warns you, because small is not a fault. So when a figure has played, look at it once: capture, then one question — do its labels read at the same distance as the sentence above it? If they do not, it wants a wider word (@at full), fewer boxes, or shorter names. Pacing and proportion for both containers are in references/charts.md.

6. Close — 收束

A hand-drawn line, the takeaway, ink on it, and a promise for next time:

markdown
---

要的不是「发得更勤」四个字,是让每一次发布都 ((小到不值得开会))。

> 下周单独讲灰度那一段的做法。

After the last word — offer the voice

A finished board is silent, and a silent board is a complete lecture: the voice is optional, always. A voice-over is a finishing pass, never a writing step — it belongs after the content has settled, because each clip is keyed to the exact sentence it speaks (rewrite that sentence afterwards and it is bought twice), and it spends the user's own key.

So it is theirs to choose and yours to raise. When the board is done, say so and put it on the table — "the board is finished; I can give it a voice, or leave it as it stands" — then do what they say. Both failures are real: a whole board synthesized unasked is money nobody agreed to, and a lecture that ends without the offer ever being made is how the voice comes to feel forgotten. Subtitles cost nothing and need no voice. Workflow: references/narration.md.

Show full SKILL.md (1,717 more words)Show less

Three disciplines

Time is not yours to manage. The lecture has no time fields — no timestamps, no delays, no cue marks; rhythm comes entirely from structure (punctuation, paragraph breaks, ---, chart layering). Any timing syntax you invent is not silently ignored — unknown marks render on the board as literal handwriting, in front of the user, and @with / @after parse as broken steps. When pacing feels wrong, fix the structure: split the paragraph, add a section, layer the chart. @wait is the one narrow escape valve.

The lecture does not forget. Nothing that has played is deleted or rewritten in board.md — the user watched it, can scrub back to it, and the Notes view keeps every word forever; the timeline is the full history and the board is its projection. @erase is an APPENDED instruction: it clears a board on stage while history keeps everything. Deleting already-played text from the file is a different act entirely — that destroys history, and it is never how a board gets cleared. Correct like a teacher (~~x~~, @strike "…", in full view), retire like a teacher (@erase). Only two kinds of in-place edit are allowed: blocks that have not yet played, and typo-level fixes that keep the block's shape. Appending is always safe — it is the move this mode is built around.

You cannot see the board by imagining it. Your markdown is the score, not the performance — what stands on which board, how much room is left, whether the words you want to point at are still up: those are facts on the stage, not in the file. Look up before you decide: call glance-board before choosing where the next batch goes, and frame-board with the @at words you mean to write when that batch deserves a place — the frames it draws are your declarations, nothing more. Look again after any edit. Judge visual effect with capture, never from source, and never keep your own outline of the board — the board's answer is the only map that cannot drift.

That bans a remembered picture of the board. It does not ban plan.md, and the difference is the whole reason both exist: the design is a promise about what you mean to teach; the board is a fact about what got written. A fact can only be read off the board, and a remembered one is stale the moment the pen moves — so ask the board, every time. A promise cannot be read off anything, because it was never on the board: you made it. Ask the design what you meant. When the two disagree, the board is right about what stands and you are still the one who decides what happens next — so look, then rewrite the promise in the file.

Never pad or reshape prose to steer where the fold breaks. Pushing a heading onto the next board with filler is fighting physics you do not control — the filler moves the fold again, and a sentence that exists for geometry is a bad sentence. If a heading lands badly, the section is too long: split it, erase a dormant board, @turn to a fresh one, or say @at and put the block where it belongs.

Viewer protocol

One lecture, one directory

A board is a content set — a top-level directory holding that lecture's board.md and theme.css (the seeds install this shape; the user flips boards with the set switcher). A new lecture means a new top-level directory. Never create a root board.md while set directories exist: a root board silently takes over and every directory board vanishes from the switcher, no error anywhere.

Naming a place on the board

Everything below uses one address, and so does the user: { "section": 1, "step": 3 }.

  • section counts from 0 (the opening); step counts from 1 inside its section — a paragraph, a list item, a chart block, a ---, a formula, a look-back and every @ line are each one step. Leave step out to name the section's own title.
  • contentSet — the board's directory. navigate-to / play-from refuse an address naming another board; capture and <viewer-locator> cross.

You never have to count these yourself. Whenever the user points at something you are handed the exact address in the message prefix — copy it verbatim.

The user pointing at the board

The user does not write this dialect. They click a step and talk. A <viewer-context mode="bansho" …> block then prefixes their message:

Board: "Why this cycle is different" — 3 sections, 21 steps, 91.8s of lecture.
Playhead: 41.2s of 91.8s, playing, following the live board.
Pointing at: narration — "Data-centre revenue tripled to 87.4B."
Address: {"section":1,"step":2}
Where: section 1, step 2 "Supply", 2 of 7
Status: already written on the board (finished at 38.6s)

Status tells you whether the board has got there yet — already written, being written right now, not written yet, or never written. If the block says the step is no longer on the board, you edited it away between their click and their message — search board.md for the quoted words, not the position.

The board is your senses — when to reach for each

POST $PNEUMA_API/api/viewer/action. Each answers one question, at one moment of the rhythm:

actionIdparamsThe question, and when to ask it
glance-board{}Look up before you write: what stands on each board (sections + step ranges), room left, where the pen is, what has been erased, and the tip. Cheap by design — call it before every append batch and after any mid-document edit.
check-board{}Did anything fail to perform? Each finding addressed to its step — run it after a batch of edits and after any warning.
capture{"address":{…}} optionalWhat do the pixels actually look like? Before judging any visual effect (composition, chart density, theme.css) — by milestone, not per append. navigate-to the tip, then capture = the final wall without playing.
navigate-to{"address":{"section":1,"step":3}}Show the user what you changed: puts the board at the moment that step finished and brings it into view.
play-from{"address":{…}}, or nothing for the top"Let me walk you through this again", from there.
narrate{}The voice-over plan: cache keys, spoken lines, both clip paths, freshness. Reach for it once the user has said yes to a voice (see After the last word), never to decide for them. Workflow in references/narration.md.
subtitles{}The lecture as finished SRT / VTT text. Save data.srt / data.vtt verbatim to the paths in data.save; never retime a cue yourself.

glance-board answers data.boards[] (per board: standing[] sections with step ranges, erased, blank, occupancy — how much of the FACE stands written on, @at ink included, the number turnUnderfilled quotes), data.pen (nextOverflow, and roomSteps — the room the PEN has: inside an @at, that region's own), data.tip and data.basis.measured — "catching-up" means ask again in a moment for the tail; check the tip echoes your latest append.

check-board answers data.ok plus data.findings: [{ code, address, message, excerpt }]. Codes: stepParseError, refUnresolved (a look-back or chart annotation that matched nothing), unsupportedStep, mathRenderError, boardOverflow (past the board's edge — the message names the edge, the px over, the responsible piece — a quoted token, an inline formula — and the fix), narrationClipMissing (clip file gone), staleTrack (the mixed narration track no longer matches this board — the board played the clips one by one instead; re-run the mixer), plus four that are not faults but what you declared: regionCollision, regionBurst, turnOnFullWall, turnUnderfilled.

Do not reach for play / pause / the playhead / speed. Those are the user's own controls over their own board.

What the board tells you unasked

Three warnings arrive on their own, once per new problem — stepParseError, refUnresolved, boardOverflow. Each spot carries its address, its own sentence — what stands wrong, by how much, and the move that fixes it — and what you wrote there. Do what the sentence says in board.md; the board keeps going regardless. And one notice, boardCollision, the first time a pair of regions comes to stand on each other — nothing moved, nothing erased, but look up before you append.

Pointing the user at a place
html
<viewer-locator label="the supply constraint" address='{"section":1,"step":3}' />
<viewer-locator label="the pitch's close" address='{"contentSet":"pitch-zh","section":2,"step":1}' />

A click takes them there — the board parks where that step finished, paused — and the second card switches boards first. A card is navigate-to in their hand and nothing more: it never plays. Name one for the PLACE it points at, never for an act it cannot perform ("play this from the top"); to offer a replay, say so in words and run play-from.

What the user can ask you for

Four buttons sit under the board; the first three name the pointed step:

  • Continue from here — keep explaining from that step; append.
  • Say this part again — they did not follow it. Rewrite that stretch more carefully; repeating the same sentences is not an answer.
  • Explain it differently — they follow the words but not the point. Take a different route to the same idea.
  • Export subtitles — run subtitles, save data.srt / data.vtt verbatim to the paths in data.save.

What this board cannot perform yet

Knowing the edges is better than discovering them on a live board:

  • Only # and ## are headings, and only - opens a list item. Everything else an editor would style, the pen writes literally (### 小节 plays as narration reading "### 小节"; 1. 2. 3. collapses into one paragraph; * 条目 keeps its asterisk) — with NO warning: the file is valid prose to check-board, so the only signal is garbage on the board.
  • A back reference can never target formula text. To the quote matcher a $…$ run is zero characters — invisible. A target that includes or crosses a formula matches nothing: an "unreadable block" badge stands in and refUnresolved warns you. Quote the plain words beside the formula instead.
  • Trend charts draw lines only. type: bar parses but is reserved.
  • Raw HTML holds its place but draws nothing — it parses, keeps its step slot, and raises unsupportedStep. (A picture — ![…](…) — is written on the board; references/illustrations.md says how.)
  • No markdown tables. Pipes are handwritten literally; the aligned list pair (- 标签:值) is this board's table.

theme.css — board tokens ONLY, always scoped

A content set's theme.css is injected verbatim into the app document. Every rule MUST be scoped under .bansho-board-surface (e.g. .bansho-board-surface { --hand: … }). A bare selector (body, div, *) restyles the app chrome around the board — never write one. Token vocabulary and ready board looks are in references/themes.md.

References — read when you need depth on the topic

TopicFile
Designing the lecture before writing it — plan.md, medium, room, lengthreferences/lecture-plan.md
The figure the board cannot draw — the two tiers, the fixed look, the batchreferences/illustrations.md
The full dialect, one paired example per formreferences/board-language.md
Charts & graphs — evidence pacing, and whether a figure is big enoughreferences/charts.md
Lecture voice: sentence length, sections, live rhythmreferences/voice-and-pacing.md
Voice-over: whether/when/who, per-sentence clips, cache keysreferences/narration.md
theme.css tokens, fonts, board looksreferences/themes.md

© pandazki, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 8 other files (scripts, references) in modes/bansho/skill of pandazki/pneuma-skills.

  • SKILL.md
  • references/board-language.md
  • references/charts.md
  • references/illustrations.md
  • references/lecture-plan.md
  • references/narration.md
  • references/themes.md
  • references/voice-and-pacing.md
  • scripts/mix-narration.mjs

Open the folder on GitHubat commit 0023d3c

Compare with similar skills

Pneuma Bansho next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Pneuma Bansho compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Pneuma Bansho this skillpandazki/pneuma-skills161—~6.9kAutomated safety check: PassMIT
HyperFrames Media Useheygen-com/hyperframes60k—~2.4kAutomated safety check: PassApache-2.0
Native Subtitle Quote Imagechengyi-ai/native-subtitle-quote-image2.6k—~2.4kAutomated safety check: PassMIT
Edu Chem Videowy51ai/edulab1.4k—~2.1kAutomated safety check: NotesApache-2.0
Transcription Memory ReconstructionNxcoreAI/EverRoom3k—~714Automated safety check: PassCustom licence
Edu Math Videowy51ai/edulab1.4k—~2.5kAutomated safety check: NotesApache-2.0

Similar skills

  • HyperFrames Media Use

    heygen-com/hyperframes

    Finds, generates and edits media for HyperFrames video projects: music, sound effects, images, icons, logos, voiceovers, captions and color grades.

    60k GitHub stars~2.4k tokensUpdated today
    Media & CreativeAuto-check passed
  • Native Subtitle Quote Image

    chengyi-ai/native-subtitle-quote-image

    将本地视频或用户有权处理的在线视频,经过来源获取、文字稿定位、选题选句、精确取帧、紧凑裁切、拼图和逐张质检,制作成 3:4 或保留画面原比例的视频字幕长图。支持两种明确分开的输出:保留画面内已烧录字幕的原生字幕模式,以及把已审核的时间点与台词绘制到真实视频帧上的脚本字幕模式。用户要求原生字幕截图、字幕帧拼图、YouTube…

    2.6k GitHub stars~2.4k tokensUpdated today
    Media & CreativeAuto-check passed
  • Edu Chem Video

    wy51ai/edulab

    A skill your agent uses when asked to make an explainer / walkthrough video (讲解视频、解题视频、例题精讲、微课) for a chemistry problem (化学题: 氧化还原配平 双线桥 电子守恒, 物质的量计算, 化学平衡 三段式 平衡常数 转化率 反应速率, 离子反应, 电化学, 溶液 滴定…

    1.4k GitHub stars~2.1k tokensUpdated yesterday
    Media & CreativeAuto-check: notes
  • Reconstruct a complete, searchable memory from an untrusted meeting or conversation transcript.

    3k GitHub stars~714 tokensUpdated 2 days ago
    Media & CreativeAuto-check passed
  • Edu Math Video

    wy51ai/edulab

    A skill your agent uses when asked to make an explainer / walkthrough video (讲解视频、解题视频、例题精讲、微课) for a math problem (数学题, geometry, algebra, functions, motion/行程 problems), from a problem screenshot…

    1.4k GitHub stars~2.5k tokensUpdated yesterday
    Media & CreativeAuto-check: notes
  • Transcribe

    JetBrains/skills

    Official

    Transcribe audio files to text with optional diarization and known-speaker hints.

    366 GitHub starsUsed in 4 repos~776 tokens
    Media & CreativeAuto-check passed

More from pandazki/pneuma-skills

All 30 skills in this repo
  • Pneuma Clipcraft

    pandazki/pneuma-skills

    AI-orchestrated video production on @pneuma-craft. An agent skill from pandazki/pneuma-skills.

    161 GitHub stars~7.5k tokensUpdated 2 days ago
    Auto-check: notes
  • Pneuma Lucid

    pandazki/pneuma-skills

    Pneuma Lucid Mode workspace guidelines. An agent skill from pandazki/pneuma-skills.

    161 GitHub stars~4.6k tokensUpdated 2 days ago
    Auto-check: warnings
  • Pneuma Plotwise

    pandazki/pneuma-skills

    Pneuma Plotwise workspace guidelines. An agent skill from pandazki/pneuma-skills.

    161 GitHub stars~8.9k tokensUpdated 2 days ago
    Auto-check passed
  • Pneuma Sprite

    pandazki/pneuma-skills

    Pneuma Sprite Mode workspace guidelines. An agent skill from pandazki/pneuma-skills.

    161 GitHub stars~16k tokensUpdated 2 days ago
    Auto-check passed
  • Pneuma Webcraft

    pandazki/pneuma-skills

    Pneuma WebCraft Mode workspace guidelines with Impeccable.style design intelligence.

    161 GitHub stars~7.5k tokensUpdated 2 days ago
    Auto-check: notes
  • Pneuma Wordtaste

    pandazki/pneuma-skills

    A goal-driven Chinese long-form writing partner. An agent skill from pandazki/pneuma-skills.

    161 GitHub stars~7.5k tokensUpdated 2 days ago
    Auto-check passed

Questions about Pneuma Bansho

What does Pneuma Bansho do?

Explain something by writing it on a board. An agent skill from pandazki/pneuma-skills. Pneuma Bansho is an agent skill from pandazki/pneuma-skills. Explain something by writing it on a board.

When should I use Pneuma Bansho?

Pneuma Bansho fits situations like: ANY task in this workspace — writing; extending board.md; re-explaining a stretch of the lecture; giving it a voice.

How do I install Pneuma Bansho in Claude Code?

Run `npx skills add pandazki/pneuma-skills --skill pneuma-bansho -a claude-code`. Or copy the skill folder (modes/bansho/skill in pandazki/pneuma-skills) into .claude/skills/pneuma-bansho in your project. Claude Code loads it when a task matches its description.

How do I install Pneuma Bansho in Codex?

Run `npx skills add pandazki/pneuma-skills --skill pneuma-bansho -a codex`. Or copy the skill folder (modes/bansho/skill in pandazki/pneuma-skills) into .agents/skills/pneuma-bansho in your project. Codex loads it when a task matches its description.

Can I use Pneuma Bansho in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add pandazki/pneuma-skills --skill pneuma-bansho -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/pneuma-bansho, .gemini/skills/pneuma-bansho, .github/skills/pneuma-bansho and .opencode/skills/pneuma-bansho in your project.

What does Pneuma Bansho need to run?

Going by SKILL.md and its folder, Pneuma Bansho needs JavaScript for the scripts in its folder. Our summary lists: Node.js.

Does Pneuma Bansho access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Pneuma Bansho safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Pneuma Bansho use?

Pneuma Bansho is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Pneuma Bansho use?

About 6.9k tokens (SKILL.md is roughly 28k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 20k tokens, read only when the agent opens those files.

What are the alternatives to Pneuma Bansho?

Skills that share tags, products or a category with Pneuma Bansho: HyperFrames Media Use (heygen-com/hyperframes, 60k stars), Native Subtitle Quote Image (chengyi-ai/native-subtitle-quote-image, 2.6k stars), Edu Chem Video (wy51ai/edulab, 1.4k stars) and Transcription Memory Reconstruction (NxcoreAI/EverRoom, 3k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Pneuma Bansho?

pandazki (a GitHub user) maintains it in pandazki/pneuma-skills, which has 161 GitHub stars. The repository holds 30 skills in this directory. The repository was last updated on October 9, 2026.

Source: pandazki/pneuma-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.