raw-app
Scaffolds Windmill raw apps using the CLI by gathering path, summary, and framework configurations.
Install
mkdir -p .claude/skills/raw-app && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/4168" && unzip -o skill.zip -d .claude/skills/raw-app && rm skill.zipInstalls to .claude/skills/raw-app
Activation
This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.
MUST use when creating raw apps.Key capabilities
- →Scaffold Windmill raw app file layout
- →Initialize frontend-backend connectivity
- →Configure app metadata
- →Create data table SDK configurations
How it works
It calls the Windmill CLI with non-interactive flags to ensure consistent directory and metadata scaffolding for platform-specific apps.
Inputs & outputs
When to use raw-app
- →Create a new internal dashboard
- →Scaffold a React-based Windmill app
- →Initialize a directory structure for a new tool
About this skill
Windmill Raw Apps — CLI workflow
This guide covers raw apps from the terminal: scaffolding via wmill app new, the on-disk layout, and the file-based conventions the CLI uses to represent backend runnables and data table configuration. The platform shape (how a raw app behaves at runtime — frontend bundling, runnable types, datatable SDK calls) is covered in the companion authoring guide.
Creating a Raw App
You — the AI agent — create the app yourself by running wmill app new with the right flags. Do NOT tell the user to "run wmill app new and follow the prompts" or wait for them to do it. The bare wmill app new is an interactive wizard that hangs waiting for stdin in any non-TTY context (which includes you). Always pass flags.
Step 1 — Settle the setup
You need three values to run the command:
- summary — a short description of the app
- path — the windmill path, e.g.
f/folder/my_apporu/username/my_app - framework — one of
react19(recommended),react18,svelte5
summary and path: if the user's request did not supply them, ask. Do not guess values and do not invent paths.
framework: never ask. Use the one the user named, otherwise the one the project's existing apps use, otherwise react19 (see "Starting a new app" in the authoring guide).
data setup: when the app has to store data and the user did not say where, ask which data table, which schema and which tables, as "Data setup" in the authoring guide lays out. wmill datatable list gives the data tables to offer.
Use whichever interactive question facility your runtime provides — a structured multi-choice tool if available, otherwise plain chat — and group everything missing into a single round-trip so the user answers at once:
- For
summaryandpath— provide one or two example values as multiple-choice options (the user can pick "Other" to type a free-form answer). - For the data setup — the choices the authoring guide lists, the default first.
Only proceed once every value is concrete. If the user replies with something ambiguous, ask again rather than guessing.
Step 2 — Run the command yourself
Once the setup is settled, run it:
wmill app new \
--summary "Customer dashboard" \
--path f/sales/dashboard \
--framework react19 \
--datatable main \
--schema app1
--summary, --path and --framework are the minimum. The datatable wizard and the "Open in Claude Desktop?" prompt are skipped silently because passing any of them puts the command in non-interactive mode, so the data setup only reaches the app through the flags below.
Optional flags
| Flag | When to add it |
|---|---|
--datatable <name> | The app stores data: the data table settled in step 1. Without it, the app is created with no datatable. |
--schema <name> | Together with --datatable, when the app's tables go in a schema, new or existing. If the schema doesn't exist yet, writes a sql_to_apply/ migration with CREATE SCHEMA IF NOT EXISTS, applied like any other migration (see "SQL Migrations" below). Leave it out for public. |
--overwrite | The target directory already exists and the user said it's OK to replace. Without it, non-interactive mode aborts with an error so you don't clobber existing work. |
--no-open-in-desktop | Already implied in non-interactive mode; only needed if you're somehow running interactively. |
Existing tables the app reuses have no flag: list them under data.tables in raw_app.yaml (see "Data tables" below).
Step 3 — Offer the visual preview
After wmill app new and any initial edits to App.tsx / index.tsx, offer to open the visual preview as a one-sentence next step (e.g. "Want me to open the visual preview?"). Don't auto-open — opening the dev page has side effects (browser window, possibly a launch.json entry when an embedded preview tool is in play) the user should consent to.
For apps the preview command runs from the app folder (cd <app_path>__raw_app && wmill app dev …); the preview skill picks the proxy vs direct branch based on whether the runtime exposes a tool that can embed a localhost URL. If the user already asked to see/preview/visualize the app in their original request, skip the offer and just invoke the skill.
Anti-patterns to avoid
- ❌ Running
wmill app newwith no flags (the prompt will hang). - ❌ Telling the user to "run
wmill app newand follow the prompts" — that's a step backwards from what you can do directly. - ❌ Inventing a path or summary instead of asking the user.
- ❌ Asking which framework to use —
react19is the default when nothing says otherwise. - ❌ Creating a schema or tables for a new app before the user has said where its data goes.
- ❌ Passing
--overwriteautomatically when the directory exists — confirm with the user first.
Interactive (only when a human is at the terminal)
wmill app new
This is the wizard. It only works when run by a human in a real terminal. Don't call it this way from an agent.
On-disk app layout
my_app__raw_app/
├── AGENTS.md # AI agent instructions (auto-generated)
├── DATATABLES.md # Database schemas (run 'wmill app generate-agents' to refresh)
├── raw_app.yaml # App configuration (summary, path, data settings)
├── index.tsx # Frontend entry point
├── App.tsx # Main React/Svelte component
├── index.css # Styles
├── package.json # Frontend dependencies
├── wmill.ts # Auto-generated backend type definitions (DO NOT EDIT)
├── backend/ # Backend runnables (server-side scripts)
│ ├── <id>.<ext> # Code file (e.g., get_user.ts)
│ ├── <id>.yaml # Optional: config for fields, or to reference existing scripts
│ └── <id>.lock # Lock file (run 'wmill generate-metadata' to create/update)
└── sql_to_apply/ # SQL migrations (dev only, not synced)
└── *.sql # SQL files to apply via dev server
Backend runnables on disk
Add a code file to the backend/ folder:
backend/<id>.<ext>
The runnable ID is the filename without extension. For example, get_user.ts creates a runnable with ID get_user.
Supported languages (extension-driven)
| Language | Extension | Example |
|---|---|---|
| TypeScript | .ts | myFunc.ts |
| TypeScript (Bun) | .bun.ts | myFunc.bun.ts |
| TypeScript (Deno) | .deno.ts | myFunc.deno.ts |
| Python | .py | myFunc.py |
| Go | .go | myFunc.go |
| Bash | .sh | myFunc.sh |
| PowerShell | .ps1 | myFunc.ps1 |
| PostgreSQL | .pg.sql | myFunc.pg.sql |
| MySQL | .my.sql | myFunc.my.sql |
| BigQuery | .bq.sql | myFunc.bq.sql |
| Snowflake | .sf.sql | myFunc.sf.sql |
| MS SQL | .ms.sql | myFunc.ms.sql |
| GraphQL | .gql | myFunc.gql |
| PHP | .php | myFunc.php |
| Rust | .rs | myFunc.rs |
| C# | .cs | myFunc.cs |
| Java | .java | myFunc.java |
After creating or editing a backend runnable — especially when its imports or arguments changed — its local lock and wmill-lock.yaml go stale. Offer to run wmill generate-metadata and run it once the user agrees (or automatically if the project's AGENTS.md opts into that) — YOU run it, don't just name it and wait. It writes local files only (not a deploy), and keeping the lock current avoids noise in git-sync/CI:
wmill generate-metadata
After it runs, check the regenerated .lock diff and tell the user which dependency versions changed (e.g. requests 2.31.0 → 2.32.0), so they can catch an unwanted bump before deploying.
Optional YAML configuration
Add a <id>.yaml file alongside the code to configure fields or static values:
backend/get_user.yaml:
type: inline
fields:
user_id:
type: static
value: "default_user"
viewer_data_access: true makes an inline runnable read data tables and object storage as the person using the app instead of as the app's identity (see "Reading data as the viewer").
Referencing existing scripts
To use an existing Windmill script instead of inline code:
backend/existing_script.yaml:
type: script
path: f/my_folder/existing_script
For flows:
type: flow
path: f/my_folder/my_flow
Data tables — raw_app.yaml config
The data block in raw_app.yaml controls which tables the app can query.
data:
datatable: main # Default datatable
schema: app_schema # Schema the app's tables go in (optional); still write them as app_schema.<table>
tables:
- main/users # Table in public schema
- main/app_schema:items # Table in specific schema
roles: # Optional: the role the app uses each datatable through
main: analyst
Table reference formats:
<datatable>— All tables in the datatable<datatable>/<table>— Specific table in public schema<datatable>/<schema>:<table>— Table in specific schema
Roles: when a datatable is under roles, its queries run as a role, which only reaches what it was granted. roles records the role the app uses each datatable through; the app's code must pass the same role: wmill.datatable('main', { role: 'analyst' }) in TypeScript, wmill.datatable('main', role='analyst') in Python. A datatable without an entry is used as its default role, if it has one, plus the roles of the app's identity, or of whoever is using the app for a runnable with viewer_data_access: true, unless that default is admin.
SQL Migrations (sql_to_apply/)
The `sql_to_ap
Content truncated.
When not to use it
- →Creating traditional apps outside the Windmill platform
- →Projects not using Windmill backend runnables
Prerequisites
Limitations
- →Requires explicit framework choice from the platform supported list
- →Cannot be used without the wmill CLI tool
How it compares
It enforces a platform-specific project structure that is otherwise only accessible through interactive prompts.
Compared to similar skills
raw-app side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| raw-app (this skill) | 0 | 5mo | Review | Beginner |
| web-component-design | 5 | 8mo | No flags | Intermediate |
| uncodixfy | 0 | 6mo | No flags | Intermediate |
| formisch-usage | 0 | 8mo | Review | Intermediate |
Try saying
Example prompts that trigger this skill in your AI assistant.
More by windmill-labs
View all by windmill-labs →You might also like
web-component-design
wshobson
Master React, Vue, and Svelte component patterns including CSS-in-JS, composition strategies, and reusable component architecture. Use when building UI component libraries, designing component APIs, or implementing frontend design systems.
uncodixfy
BrammekeTV
Prevents generic AI/Codex UI patterns when generating frontend code. Use this skill whenever generating HTML, CSS, React, Vue, Svelte, or any frontend UI code to enforce clean, human-designed aesthetics inspired by Linear, Raycast, Stripe, and GitHub instead of typical AI-generated UI.
formisch-usage
sandros94
Form handling with Formisch, the type-safe form library for modern frameworks. Use when the user needs to create forms, handle form state, validate form inputs, or work with Formisch.
webf-quickstart
openwebf
Get started with WebF development - setup WebF Go, create a React/Vue/Svelte project with Vite, and load your first app. Use when starting a new WebF project, onboarding new developers, or setting up development environment.
app_runner
k4ilham
A skill to run the backend (Go Fiber) and frontend (React/Vite) applications. It includes pre-run checks to clear the required ports (8080 and 5173) if they are already in use.
screenshot-to-code
OneWave-AI
Convert UI screenshots into working HTML/CSS/React/Vue code. Detects design patterns, components, and generates responsive layouts. Use this when users provide screenshots of websites, apps, or UI designs and want code implementation.