I use Claude in two places, and they are not the same thing. Claude Code runs in the terminal, sees this machine, and can act on it—including editing this wiki itself through the API. The web app runs in the browser and sees only what I paste into it. What follows is how each is used, and above all how what it produced gets out of it and into the wiki intact.
That last part is the whole difficulty, and it has one cause: what must survive is the Markdown. Module:AI turns Markdown into wikitext by itself, so an answer wants to arrive exactly as Claude emitted it—not hand-converted, and not as it appears on screen. Both a terminal copy and a browser copy destroy that Markdown, in different ways, and each has its own remedy.
| Where the answer is | What I want out of it | What I do |
|---|---|---|
| Claude Code | it goes to the wiki as it stands | wiki this to <page>—Claude posts it itself, no copy step |
| I want to edit it first | ClaudeClip me <passage>—it lands on the clipboard, ready to paste | |
| only a table in it | Ctrl+Alt+ShiftRight+W (mdtable2wiki) rebuilds it from the box glyphs | |
| the web app | any answer, into my own prose | copy it: html2md has already turned it into wikitext—just paste |
| an answer going inside {{AI}} | Ctrl+Alt+ShiftRight+H, which gives the Markdown that box needs | |
| a table becoming a wikitable | Ctrl+Alt+W, or Ctrl+Alt+ShiftRight+W for one going inside {{AI}} |
Instruct it to wiki this to <page>. Claude does the edit through the API: it wraps the exchange in {{AI}}, fetches the current revision, shows me the diff, and posts with basetimestamp. Nothing passes through a copy step, so nothing can be mangled, and nothing has to be reformatted by hand.
It works under standing rules, which are worth knowing because they explain what it will and will not do:
basetimestamp, so an edit of mine made in the meantime comes back as an editconflict instead of being silently overwritten.silent-lwedit, which writes at the same timestamp. Real activity—a new page, a new section—is a normal edit.Saying ClaudeClip me <passage> to any Claude Code session puts the {{AI}}-wrapped, wiki-proof version of that answer on the clipboard, ready to paste with no further step. The recipe is a skill on disk, not a conversation, so it works from any session, any day: Claude recovers the original Markdown—from the running conversation, or by grepping the session transcripts under ~/.claude/projects/ when the passage comes from elsewhere. Quoting the passage from a terminal copy is fine—it is only used to find the real thing, so any distinctive verbatim phrase does.
On the way it applies the safety rules by itself: every literal pipe becomes {{!}} (so tables and | in prose no longer force src=), a table that arrives as box-drawing glyphs is rebuilt through mdtable2wiki --ai, code-block lines too long for the box are reflowed, and the result is parse-checked against the wiki before it is handed over.
Konsole copies what is displayed, and the console has already rendered the Markdown away: tables become box-drawing glyphs, the bold, italic and code markers are stripped, every visual wrap becomes a hard line break—against the one-paragraph-one-line rule—and long lines can come out truncated or scrambled outright.
So the text on screen and the text Claude emitted are two different things, and only the second one belongs in the wiki. It has not been lost: it sits in the session transcript. grep -rl "<distinctive phrase>" ~/.claude/projects/ finds the .jsonl, and the block inside it is the pristine answer—which is exactly what ClaudeClip does for me. For a table alone there is no need to go that far: mdtable2wiki -x -c --ai, i.e. Ctrl+Alt+ShiftRight+W, reads the box glyphs off the clipboard and gives back a wikitable whose structural pipes are {{!}}, safe inside a=.
Here Claude has no access to my machine and I have only the rendered page. Selecting a piece of it with the mouse gives a poor copy: the structure is flattened and every formula falls apart into loose glyphs, sometimes doubled, because that is what the plain-text flavour of the clipboard holds.
It is only that flavour that is impoverished. The same copy also sits on the clipboard as text/html, and KaTeX keeps the $\mathrm{\TeX}$ it was given inside the MathML annotation of each formula, so the LaTeX is already there—it is the paste that throws it away. html2md reads the other flavour and hands back the structure, maths included; where the page is rendered by MathJax, which keeps no LaTeX at all, it rebuilds the LaTeX from the MathML tree.
Since 2.0.0 what it hands back is wikitext, not Markdown: bold, == headings ==, * lists, {| class="wikitable" tables, $…$ maths. That is the language this wiki is written in, so a copied answer can be pasted into a page as it stands. Markdown is one flag away, -m, and it is not a curiosity: it is what the {{AI}} box wants (below).
There is no step in between: a watcher started at login converts every copy as it arrives, setting the Markdown as the plain-text flavour and putting the original HTML back in place, so rich pastes still work elsewhere. What lands in the edit box is ready-made wikitext, with $...$ and $$...$$ that SimpleMathJax renders. Meta+F9 runs the same conversion by hand, should the watcher have died—and the watcher, being a running process, keeps the version it was started with: a new one takes only after it is restarted.
Two flavours travel together and applications do not choose the same one. A plain textarea—the wiki edit box, Emacs, a terminal—can only read text/plain, which is the converted Markdown, so there it works. A rich box—Claude's own prompt form, a mail, a word processor—prefers text/html, and the watcher deliberately leaves that flavour untouched so that pasting into those keeps its formatting. What arrives there is therefore the original, not the Markdown, and it looks as though nothing had happened.
The cure is to press a key, because the hotkeys own the clipboard themselves and offer the plain flavour only. After Meta+F9, or Ctrl+Alt+H, or Ctrl+Alt+W, the HTML flavour is simply gone from the clipboard, and every application—Claude's form included—has no choice but to take the Markdown. That is also the way to hand an answer back to Claude as Markdown rather than as a rendered blob.
The watcher does not ignore tables: a copied table comes back as a Markdown table, rows and all. The trouble is that a Markdown table is of no use on this wiki. Outside {{AI}} nothing renders Markdown at all, and inside a= the literal pipe in every row cuts the template parameter to pieces. So the conversion has happened and yet nothing usable came of it.
Since 2.0.0 the automatic conversion answers the commonest case by itself: a copied table arrives as a real {| class="wikitable", pipes in the cells already |, ready to paste into a page. What it cannot do is guess the other destination, and that is what the keys are for.
Inside {{AI}} the wikitext is not merely unnecessary but wrong: Module:AI converts Markdown itself, and reads a leading **—which is how wikitext nests a list—as bold, so the list falls apart. Six items became four in the specimen I measured. Ctrl+Alt+ShiftRight+H is therefore the key for that box: Markdown, with every pipe written {{!}} so that tables and code blocks survive the a= parameter. Ctrl+Alt+H is the plain one, wikitext for a page, and Ctrl+Alt+W remains the table alone, mdtable2wiki doing the alignment and the width that html2md does not attempt.
For that second road: a table in the answer is a real HTML table in the page, so mdtable2wiki takes it directly off the text/html flavour—the Markdown source is never needed, and the maths comes back verbatim from the same KaTeX annotation. Ctrl+Alt+W converts whatever table is on the clipboard into a full-width wikitable; Ctrl+Alt+ShiftRight+W writes its structural pipes as {{!}} for a table that has to sit inside the a= of {{AI}}. Both are keymapper bindings, listed with the rest on Keystrokes.
Whatever the route, an exchange is recorded as raw Markdown inside {{AI}}—not wikitext, since Module:AI converts Markdown itself and hand-converting silently loses things.
{{AI|AI=Claude|v=Opus 5|q=my prompt, verbatim|a=
the markdown answer, exactly as emitted
}}
AI=Claude gives the logo and the tint, so it reads at a glance as a Claude output rather than as my own prose; v= (or model=) is the model. Second person (your machine) is correct inside the box: it is a quoted exchange. The human defaults to Fabrice.
A literal | anywhere in the answer breaks the a= parameter, since that is where MediaWiki cuts template arguments. Two ways out: write each pipe as {{!}}, which expands back to | before the module ever reads it—the table recipes are in Template:AI's documentation, and ClaudeClip and mdtable2wiki --ai do it by themselves—or save the reply to a subpage and point src= at it, which is read verbatim, so pipes, tables, braces and = are all safe. An = on its own is fine in a=.
<syntaxhighlight>It renders white-space: pre and never wraps, so each one-line paragraph becomes a single ~500-character line: measured once at 3786 px of sideways scrolling in a 538 px box. It also shows **bold** and the inner fences as literal characters, leaving the code un-highlighted. The {{AI}} box is what displays an answer; <syntaxhighlight> is for code, inside it.
Keep code-block lines short. A trailing # comment pushes a ~580 px box into horizontal scrolling; the comment goes on its own line above the command. Overlong lines now scroll rather than being clipped mid-word, but a scrollbar hides the ending just as effectively.
Long entries go inside {{show top}} … {{show bottom}}, my collapsible—remembering that this hides the Claude branding until it is expanded, so the wrapper is dropped whenever attribution at a glance is the point.