New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Drive Frontend

by WolframResearch in WolframResearch/Chatbook

Drive a real Wolfram front end (WolframNB) to test Chatbook's actual UI: launch a fresh front end on a private Xvfb display (optionally with the development Chatbook loaded) or attach to one that is…

MITAuto-check passedFrontend & Design

Install Drive Frontend

skills CLI
$ npx skills add WolframResearch/Chatbook --skill drive-frontend -a claude-code

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

GitHub CLI
$ gh skill install WolframResearch/Chatbook drive-frontend --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/WolframResearch/Chatbook.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/drive-frontend .claude/skills/drive-frontend && 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
drive-frontend
GitHub stars
124
Token cost
~2.9k tokens
SKILL.md length
1,320 words
Files
1
Skills in repo
3
Repo updated
First seen
Licence
MIT

At a glance

Drive a real Wolfram front end (WolframNB) to test Chatbook's actual UI: launch a fresh front end on a private Xvfb display (optionally with the development Chatbook loaded) or attach to one that is…

  • Works in 4 steps: Get a front end → Core commands → Chatbook recipes → …
  • Frontend & Design work in your project
  • SKILL.md covers 1. Get a front end, 2. Core commands, 3. Chatbook recipes and 4. Troubleshooting
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Drive Frontend is an agent skill from WolframResearch/Chatbook. Drive a real Wolfram front end (WolframNB) to test Chatbook's actual UI: launch a fresh front end on a private Xvfb display (optionally with the development Chatbook loaded) or attach to one that is already running, evaluate code in its kernel, list notebooks and cells, take screenshots, and click, type, or press buttons by BoxID, text, or screenshot coordinates. Use this whenever a task involves seeing or interacting with Chatbook UI - the notebook assistant window, sidebar, chat bar, chat notebooks, output…

Its SKILL.md is about 2.9k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Frontend & Design. The repository describes itself as: Wolfram Notebooks + LLMs. The licence is MIT.

When your agent uses it

  • Frontend & Design work in your project

Example prompts

  • “check how this renders in the front end”
  • “reproduce this UI bug”
  • “verify the new button works”
  • “/drive-frontend”

Workflow steps

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

  1. Get a front end
  2. Core commands
  3. Chatbook recipes
  4. Troubleshooting

What it can do on your machine

Read from SKILL.md and the folder at commit 1dc660a. 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

    No scripts in the folder and no shell commands in SKILL.md (its code samples are bash and wl).

    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

Drive Frontend loads about 2.9k tokens when it runs. Until then it costs about 193 tokens; SKILL.md has 1,320 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~193
When it runs · the whole SKILL.md, loaded when a task matches
~2.9k

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); files beside SKILL.md are not scanned.

SKILL.md

The full file from WolframResearch/Chatbook at commit 1dc660a, republished under its MIT licence (© WolframResearch). 1,320 words, ~2,890 tokens.

Download SKILL.mdSave it as .claude/skills/drive-frontend/SKILL.md (or your agent's skills folder).
name
drive-frontend
description
Drive a real Wolfram front end (WolframNB) to test Chatbook's actual UI: launch a fresh front end on a private Xvfb display (optionally with the development Chatbook loaded) or attach to one that is already running, evaluate code in its kernel, list notebooks and cells, take screenshots, and click, type, or press buttons by BoxID, text, or screenshot coordinates. Use this whenever a task involves seeing or interacting with Chatbook UI - the notebook assistant window, sidebar, chat bar, chat notebooks, output formatting, buttons and menus - for example "check how this renders in the front end", "reproduce this UI bug", "verify the new button works", "take a screenshot of the assistant window", or after changing UI code, "make sure it still works".

Driving a Wolfram front end

All tools live in Developer/FrontEndServer/ (its README.md explains the design). Use the client by absolute path, since the shell's working directory may change between commands:

bash
fe=/home/ubuntu/Chatbook/Developer/FrontEndServer/fe.py   # adjust to the repository location

1. Get a front end

Fresh, isolated front end (preferred for testing). It runs on its own Xvfb display, so it never touches the user's desktop:

bash
$fe launch --chatbook   # loads the development Chatbook from this repo (BoxIDs etc. match the source)
$fe launch              # uses the installed Chatbook paclet instead

It prints the port, e.g. fe-2400 ... port 2400. Startup takes 20-60 s. Always $fe -s PORT stop when done (it quits the front end and its Xvfb). $fe servers lists what is running; $fe servers --prune cleans up leftovers.

Memory: each front end (with its kernels) uses about 1 GB. Run as few as possible at once and stop them promptly; running a machine out of memory gets unrelated processes killed, which can take down the user's desktop session. launch refuses to start when less than 2 GB is available. Don't launch front ends from parallel subagents.

The user's own front end. Ask the user to evaluate:

wl
Get["<repo>/Developer/FrontEndServer/FrontEndServer.wl"]; Wolfram`ChatbookFrontEndServer`StartFrontEndServer[]

Be considerate there: mouse/keyboard input moves the user's real pointer and focus, so prefer read-only commands, press (no mouse) and eval, and don't close or modify their notebooks without being asked. stop only stops the server in a front end that fe.py did not launch.

Several servers. When more than one is running, every command needs -s PORT (or -s NAME). With exactly one running, -s can be omitted. Other agents may be running their own servers: always pass -s with your port.

2. Core commands

GoalCommand
Evaluate code in the front end's kernel$fe eval 'expr' (- reads stdin, @file.wl reads a file)
Evaluate as a real input cell (In/Out, like Shift+Enter)$fe eval --cell 'expr' [--notebook NB]
Wait for pending evaluations / a condition$fe wait / $fe wait 'cond' --timeout 120
List notebooks / cells$fe nbs / $fe cells NB (--attached, --sidebar)
Read a cell$fe read CELLID [--format Markdown]
Screenshot a window (prints a PNG path; view it with Read)$fe screenshot NB [--scale 0.5] [-o file.png]
Screenshot a cell / the whole screen$fe screenshot --cell CELLID / $fe screenshot --screen
Find a control on screen$fe locate --box BOXID --notebook NB (also --text TEXT, --cell CELLID)
Real mouse click$fe click --box BOXID --notebook NB, --text TEXT, --cell ID, --image U,V, or X,Y
Activate a control without the mouse$fe press BOXID --notebook NB
Keyboard$fe type 'text' [--cell ID], $fe key shift+Return, $fe key ctrl+a BackSpace
Put the cursor into a cell / focus a window$fe focus --cell CELLID / $fe focus NB
Ask the assistant (window or sidebar) and print the reply$fe ask 'question' / $fe ask 'question' --sidebar NB
Menu commands$fe token SelectAll --notebook NB (front end tokens; names are not validated)
Messages window$fe messages [--clear]
Hover / scroll / drag$fe move ..., $fe scroll X,Y --clicks 3, $fe drag X0,Y0 X1,Y1
Reload server code after editing FrontEndServer.wl$fe reload

NB is a notebook title (exact, or a unique substring), an id from nbs, selected, input, or messages. Cell ids come from cells; if an id is ambiguous (attached cells can share ids across notebooks), use the full CellObject[...] from $fe --json cells ... (field object).

Notes:

  • Requests wait for the kernel. They run in the kernel's main loop, so while a cell or a chat is evaluating, requests are answered only after it finishes; $fe wait relies on this. Add --preemptive to read state during a long evaluation (e.g. $fe --preemptive eval 'WolframChatbook$ChatEvaluationCell'); keep such requests read-only. Right after sending a chat, use the queued wait (a preemptive check may run before the chat starts).
  • Inside eval, EvaluationNotebook[] is a hidden helper notebook. Refer to notebooks and cells with Wolfram`ChatbookFrontEndServer`FrontEndServerNotebook["title or id"] (and FrontEndServerCell["id"]), or use SelectedNotebook[] / eval --cell. eval code runs in Global` of the front end's kernel.
  • Use fully qualified names for Chatbook symbols (Wolfram`Chatbook`...); Chatbook is not on $ContextPath.
  • locate, and therefore click --box/--text/--cell, moves the notebook's selection to the target (and scrolls it into view). Keep that in mind when testing selection-dependent features (e.g. AllowSelectionContext). --text is case-sensitive; text the front end can't search (inside chat messages, buttons, docked/attached cells) falls back to the rectangle of the whole cell containing it.
  • Screenshots go to a temp directory (printed); pass -o to choose the file. Use --scale 0.5 for overviews (fewer tokens), full scale to read small text. click --image U,V maps a point of the last screenshot back to the screen.
  • After a click or keystroke that changes the UI, sleep 0.5-1 before the next screenshot.
  • Keyboard input goes to the focused window: click into the target, focus --cell ID, or select NB first. Escape starts an alias inside a notebook (it is not "cancel"), but it does close open menus and popups.
  • Cell text containing private-use characters is shown with their names, e.g. \[FreeformPrompt].
  • After changing Chatbook source, reload it in the front end's kernel: $fe eval 'PacletDirectoryLoad["<repo>"]; Get["WolframChatbook"]' (UI that is already open keeps the old code; reopen windows). Changes to front end resources (stylesheets, FrontEnd/ files) need launch --chatbook again.
Show full SKILL.md (487 more words)Show less

3. Chatbook recipes

Notebook assistant window (each question is a real LLM call):

bash
$fe eval --timeout 180 'Wolfram`Chatbook`ShowNotebookAssistance[None, "Window", "Input" -> "What is 2+2?",
  "NewChat" -> True, "EvaluateInput" -> True,
  "ChatNotebookSettings" -> <|"AutoSaveConversations" -> False, "AllowSelectionContext" -> False|>]'
$fe cells 'Wolfram AI Assistant'          # ChatInput / ChatOutput cells with their text
$fe ask 'And what is 3+3?'                # types into the input field like a user, sends, prints the reply
$fe screenshot 'Wolfram AI Assistant'

The ShowNotebookAssistance call blocks until the reply is complete. The window title is "Wolfram AI Assistant". Step by step instead of ask: click --box AttachedChatInputField --notebook 'Wolfram AI Assistant', type '...', key Return (or click --box NASendChatButton ...), then wait 'WolframChatbook$ChatEvaluationCell === None'.

Sidebar: $fe eval 'WolframChatbookShowNotebookAssistance[WolframChatbookFrontEndServerFrontEndServerNotebook["NB"], "Sidebar"]' (it ignores "Input"), then $fe ask 'question' --sidebar NB, or click with --in sidebar (click --box AttachedChatInputField --notebook NB --in sidebar). List its messages with $fe cells NB --sidebar.

Chat notebook: $fe eval 'WolframChatbookCreateChatNotebook[]' creates a notebook with one empty ChatInput cell: $fe cells NB, $fe type 'question' --cell <ChatInput id>, $fe key Return (Return sends; Shift+Return is a newline in chat input cells). New cells in a chat notebook are Input cells: to ask a follow-up, click below the last cell and type ' first, which turns the new cell into a ChatInput.

Useful BoxIDs (only present with the development Chatbook, i.e. launch --chatbook):

WhereBoxIDs
Assistant window toolbarNANewChatButton, NASourcesToggle, NAHistoryToggle, NAOpenAsChatbookButton
Assistant inputAttachedChatInputField, NASendChatButton, NAStopChatButton (while a chat runs)
Output tray (hover over a reply first: move --cell ID)NARegenerateAssistantMessageButton, NAThumbsUpButton, NAThumbsDownButton
History overlayNAHistoryFirstPage, NAHistoryPageLeft, NAHistoryPageRight, NAHistoryLastPage, NAHistorySearchButton
Sidebar (use --in sidebar)NASidebarNewChat, NASidebarSourcesToggle, NASidebarHistoryToggle, NASidebarOpenAsAssistantWindowButton, NASidebarClose, AttachedChatInputField, NASidebarChatInputCellSendButton
Chat bar (bottom of notebooks)AttachedChatInputField, NAChatbarChatInputCellSendButton, NAChatbarOptionsButton
Inline chatNACloseInlineChat, NAPopOutAsWorkspaceChat

Find more with grep -rn 'BoxID' Source/Chatbook. Controls built with EventHandler (tool-call expanders, focus checkboxes, "Copy as" menus, code block buttons) have no BoxID: locate them in a screenshot and click --image U,V.

Chat state from outside:

  • Wolfram`Chatbook`$ChatEvaluationCell is the chat input cell while a chat runs (in that kernel), else None.
  • Reply text: $fe cells NB (or --sidebar), $fe read ID --format Markdown, or CurrentValue[cell, {TaggingRules, "CellToStringData"}].
  • Errors: $fe messages; service errors replace the reply with a framed Text cell (⚠); WolframChatbook$LastChatbookFailureText holds the last internal failure.

Avoid side effects: pass "AutoSaveConversations" -> False (otherwise chats are saved and titled with an extra LLM call). Don't click the feedback Send button (it posts to Wolfram), sign-in buttons, or chat bar state setters (NAChatbarSetterState*, minimize/maximize); they persist front end options. Modal dialogs (ChoiceDialog, DialogInput) block the kernel: requests time out until the dialog is closed (screenshot, then click a button).

4. Troubleshooting

  • "Timed out ... the kernel is busy": an evaluation is running; wait, raise --timeout, or use --preemptive.
  • "does not answer pings either": the kernel is blocked; $fe screenshot --screen to look for a dialog. A launched front end can always be killed with $fe stop.
  • "Several front end servers are running" / "Several notebooks match": add -s PORT / use a more specific name.
  • BoxNotFound: the control may only exist while hovering or while a chat runs, may live in another place (--in sidebar), or may be missing from the installed Chatbook (use launch --chatbook).
  • A located rectangle looks wrong: take a screenshot and use click --image.
  • $fe --json <command> prints raw results (and errors as JSON).

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

Files

Just SKILL.md in .claude/skills/drive-frontend of WolframResearch/Chatbook.

Open the folder on GitHubat commit 1dc660a

Compare with similar skills

Drive Frontend 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.

Drive Frontend compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Drive Frontend this skillWolframResearch/Chatbook124—~2.9kAutomated safety check: PassMIT
Web Artifacts Builderanthropics/skills180k40 repos~769Automated safety check: PassApache-2.0
React Doctormakeplane/plane61k12 repos~657Automated safety check: PassAGPL-3.0
Impeccablebestofjs/bestofjs3.1k26 repos~2.6kAutomated safety check: PassMIT
Figma Design System Builderwarpdotdev/warp65k2 repos~4.4kAutomated safety check: PassAGPL-3.0
Web Interface Guidelines Reviewervercel-labs/openreview1.7k97 repos~308Automated safety check: PassNone

Similar skills

  • Web Artifacts Builder

    anthropics/skills

    Official

    Builds multi-component claude.ai HTML artifacts as a small React, TypeScript and Tailwind project, then bundles it into one shareable HTML file.

    180k GitHub starsUsed in 40 repos~769 tokens
    Frontend & DesignAuto-check passed

  • React Doctor

    makeplane/plane

    Scans React code for lint, accessibility, bundle size and architecture issues, reports a health score and checks that changes do not lower it.

    61k GitHub starsUsed in 12 repos~657 tokens
    Frontend & DesignAuto-check passed

  • Impeccable

    bestofjs/bestofjs

    A skill your agent uses when the user wants to design, redesign, shape, critique, audit, polish, clarify, distill, harden, optimize, adapt, animate, colorize, extract, or otherwise improve a…

    3.1k GitHub starsUsed in 26 repos~2.6k tokens
    Frontend & DesignAuto-check passed

  • Figma Design System Builder

    warpdotdev/warp

    Builds or updates a design system in Figma from a codebase in ordered phases: discovery, variables and tokens, components, theming and documentation, with checkpoints.

    65k GitHub starsUsed in 2 repos~4.4k tokens
    Frontend & DesignAuto-check passed

  • Web Interface Guidelines Reviewer

    vercel-labs/openreview

    Official

    Review UI code for Web Interface Guidelines compliance. Use when asked to "review my UI", "check accessibility", "audit design", "review UX", or "check my…

    1.7k GitHub starsUsed in 97 repos~308 tokens
    Frontend & DesignAuto-check passed

  • Tailwindcss Development

    anonaddy/anonaddy

    Always invoke when the user's message includes 'tailwind' in any form.

    4.9k GitHub starsUsed in 10 repos~865 tokens
    Frontend & DesignAuto-check passed

More from WolframResearch/Chatbook

  • Triage Failure Reports

    WolframResearch/Chatbook

    Triage Chatbook's auto-generated bug-report issues on GitHub by grouping them on their Failure Data signature (the failing Wolfram Language function plus the confirmed expression/pattern), finding…

    124 GitHub stars~2.7k tokensUpdated today
    Auto-check passed

  • Test Skill

    WolframResearch/Chatbook

    Verifies that Chatbook's agent skill support is working. An agent skill from WolframResearch/Chatbook.

    124 GitHub stars~186 tokensUpdated today
    Auto-check passed

Categories

Questions about Drive Frontend

What does Drive Frontend do?

Drive a real Wolfram front end (WolframNB) to test Chatbook's actual UI: launch a fresh front end on a private Xvfb display (optionally with the development Chatbook loaded) or attach to one that is…. Drive Frontend is an agent skill from WolframResearch/Chatbook. Drive a real Wolfram front end (WolframNB) to test Chatbook's actual UI: launch a fresh front end on a private Xvfb display (optionally with the development Chatbook loaded) or attach to one that is already running, evaluate code in its kernel, list notebooks and cells, take screenshots, and click, type, or press buttons by BoxID, text, or screenshot coordinates.

When should I use Drive Frontend?

Drive Frontend fits situations like: frontend & Design work in your project.

How do I install Drive Frontend in Claude Code?

Run `npx skills add WolframResearch/Chatbook --skill drive-frontend -a claude-code`. Or copy the skill folder (.claude/skills/drive-frontend in WolframResearch/Chatbook) into .claude/skills/drive-frontend in your project. Claude Code loads it when a task matches its description.

How do I install Drive Frontend in Codex?

Run `npx skills add WolframResearch/Chatbook --skill drive-frontend -a codex`. Or copy the skill folder (.claude/skills/drive-frontend in WolframResearch/Chatbook) into .agents/skills/drive-frontend in your project. Codex loads it when a task matches its description.

Can I use Drive Frontend 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 WolframResearch/Chatbook --skill drive-frontend -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/drive-frontend, .gemini/skills/drive-frontend, .github/skills/drive-frontend and .opencode/skills/drive-frontend in your project.

What does Drive Frontend need to run?

SKILL.md names no scripts, command-line tools or credentials: Drive Frontend is instructions for the agent only.

Does Drive Frontend 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 Drive Frontend 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. Review the folder before installing.

What licence does Drive Frontend use?

Drive Frontend 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 Drive Frontend use?

About 2.9k tokens (SKILL.md is roughly 12k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Drive Frontend?

Skills that share tags, products or a category with Drive Frontend: Web Artifacts Builder (anthropics/skills, 180k stars), React Doctor (makeplane/plane, 61k stars), Impeccable (bestofjs/bestofjs, 3.1k stars) and Figma Design System Builder (warpdotdev/warp, 65k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Drive Frontend?

WolframResearch (a GitHub organization) maintains it in WolframResearch/Chatbook, which has 124 GitHub stars. The repository holds 3 skills in this directory. The repository was last updated on October 9, 2026.

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