Introduction
pdum_aiui is a workflow — and the tooling and knowledge to support it — for rapidly building scientific and technical visualization UIs with AI agents, in a tight iteration loop. It keeps an ordinary, interactive Claude Code CLI session at the center, and builds a higher-bandwidth way of prompting on top of it: speak, point, screenshot — and let a lowering layer compile that intent into the prompt the agent actually receives.
Before you run anything
This codebase currently launches Claude Code with permissions skipped and injects prompts into the live session through a custom channel. It is safer to read than to run — see Read before running.
The three layers
1. Prompt lowering (intent compilation). A user expresses intent at a high level of abstraction, multimodally — audio instead of a keyboard, screenshots, DOM context, even pronouns ("make this wider"). A pipeline of utility LLMs and intelligent logic lowers that prompt, the way a compiler lowers through intermediate representations, into the form that's optimal for Claude Code — which today means interleaved text and images, not just text — then injects it into the running session via a custom channel. This is also framed as a research area: the pipeline should expose its intermediate representations for inspection, like compiler IRs. → Prompt Lowering
2. Concrete intent tools. The lowering pipeline needs frontends. The current one is the intent client: one client, two hosts — the session browser's side panel and the channel-served plain page at /intent/ — driving the page you're developing: speak the change you want, capture screenshots, draw on the page, select the thing you mean, and send it all through lowering to your session. It cooperates with the Chrome DevTools MCP and annotates the app's affordances in a superset of WebMCP. → The Intent Panel
3. Frontend code for agents. Principles, utilities, examples, and workflows — a TypeScript library plus Claude skills — for the kind of code agents should write in this loop: SolidJS 2.0 (beta), Observable-style async dataflow in mainstream syntax, comprehensible to humans even where it's more tedious than a human would write, and debuggable by the agent's future self (source locators, self-installed debug hooks, HMR-mindful, WebMCP-annotated). This instrumentation is also what makes lowering sharp — it's how a screenshot rectangle resolves to the components and source behind it. A separate module from the intent tool. → Frontend for Agents
A workflow, not a product
This project is unapologetically optimized for its author's way of working: watching the Claude Code transcript live, interrupting, dictating instead of typing. You may share the goals and still prefer a different shape — the Motivation page tells the honest story so you can decide. Many parts (channel registry, prompt injection, session discovery, the TUI test harness) are useful raw material for building your own version of this workflow.
The repo, practically
A pnpm + TypeScript monorepo. Packages live under packages/* in the @habemus-papadum scope, versioned in lockstep (one shared version). The docs you're reading are generated from the same packages/* glob — every package contributes its README, hand-written guides, and a TypeDoc API reference automatically.
Where to go next
- Motivation — a personal workflow — why this exists, in first person.
- Getting Started — keys, then the three run modes.
- The Intent Panel — the feature reference: dictation, capture, the linter, the oracle, the pencil, the trace debugger.
- Prompt Lowering — the core idea, mechanism, and research program.
- Configuration — config.json: locations, keys, precedence.
- Frontend for Agents — how the code itself should be written (the library's own guides live with the package).
- ⚠️ Read before running — the security posture, plainly.
- Packages — the package index, per-package guides (the agent's browser, remote development, DuckDB, VS Code), and API references.
- Developing pdum_aiui — working on this repo: workspace, docs system, releasing.