Agent skill

Fast Dash

by dkedar7 in dkedar7/fast_dash

Build a Fast Dash web app from a Python function. An agent skill from dkedar7/fast_dash.

MITAuto-check passedData & Analytics

Install Fast Dash

skills CLI
$ npx skills add dkedar7/fast_dash --skill fast-dash -a claude-code

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

GitHub CLI
$ gh skill install dkedar7/fast_dash fast-dash --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/dkedar7/fast_dash.git skills-src && mkdir -p .claude/skills && cp -r skills-src/plugins/fast-dash/skills/fast-dash .claude/skills/fast-dash && 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
fast-dash
GitHub stars
129
Token cost
~1.9k tokens
SKILL.md length
798 words
Files
4 (incl. references)
Skills in repo
1
Repo updated
First seen
Licence
MIT

At a glance

Build a Fast Dash web app from a Python function. An agent skill from dkedar7/fast_dash.

  • Works in 4 steps: Start from the user's function. If they… → Add type hints and defaults. This is… → Decorate with @fastdash. For more… → …
  • The user wants to turn a function into an interactive app
  • SKILL.md covers When to use this skill, Install, The core pattern and How to approach a Fast Dash task, plus 6 more sections
  • Calls pip

What it does

Fast Dash is an agent skill from dkedar7/fast_dash. Build a Fast Dash web app from a Python function. Use when the user wants to turn a function into an interactive app, add a UI to an existing function, build a dashboard / form / wizard, add a chat assistant to an app, or make an app that AI agents can drive over MCP. Fast Dash infers UI components from type hints, so a well-typed function becomes an app with one decorator.

Its SKILL.md is about 1.9k tokens, which your agent loads only when the skill is triggered. The skill folder holds 4 other files, including reference files (for example `references/components.md`, `references/gotchas.md` and `references/patterns.md`).

It sits in Data & Analytics, covering Type safety. It works with Python, Model Context Protocol, Plotly and Flask. The repository describes itself as: Turn your Python functions into interactive apps! Fast Dash is an innovative way to deploy your Python code as interactive web apps with minimal changes. The licence is MIT.

When your agent uses it

  • The user wants to turn a function into an interactive app
  • Add a UI to an existing function
  • Build a dashboard / form / wizard
  • Add a chat assistant to an app

Example prompts

  • “/fast-dash”

Requirements

  • Python 3

Workflow steps

4 steps, taken from the first numbered list in SKILL.md.

  1. Start from the user's function. If they don't have one, write the smallest function that captures their intent.
  2. Add type hints and defaults. This is where the UI comes from — int → number input, bool → checkbox, str with a list default → dropdown…
  3. Decorate with @fastdash. For more control (tabbed multi-function apps, multi-step pipelines), use the FastDash(...) class directly.
  4. Run and verify. The decorator starts a server immediately on import. For notebooks, pass mode="inline".

What it can do on your machine

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

    Shell commands in SKILL.md call:

    • pip

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

  • Network

    No URLs in SKILL.md. Its commands use pip, which can reach the network depending on how they are called.

    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

Fast Dash loads about 1.9k tokens when it runs, and up to ~6.1k if it reads all its reference files. Until then it costs about 97 tokens; SKILL.md has 798 words of instructions outside code blocks.

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

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 dkedar7/fast_dash at commit e87489a, republished under its MIT licence (© dkedar7). 798 words, ~1,918 tokens.

Download SKILL.mdSave it as .claude/skills/fast-dash/SKILL.md (or your agent's skills folder). This skill also uses 3 other files; get the full folder from GitHub.
name
fast-dash
description
Build a Fast Dash web app from a Python function. Use when the user wants to turn a function into an interactive app, add a UI to an existing function, build a dashboard / form / wizard, add a chat assistant to an app, or make an app that AI agents can drive over MCP. Fast Dash infers UI components from type hints, so a well-typed function becomes an app with one decorator.

Fast Dash

Fast Dash turns a Python function into a Plotly Dash web app. The @fastdash decorator reads the function's signature, maps each parameter's type hint to a UI component, maps the return type to an output component, and serves the result. No frontend, no callbacks, no boilerplate.

When to use this skill

Use this skill when the user:

  • has a Python function and wants a UI for it ("make this a web app", "add a form", "dashboard around this")
  • is prototyping an ML / data / API tool and wants shareable interactivity
  • needs cascading inputs, a multi-step wizard, or multiple tools in one app
  • wants an AI agent (Claude Code, Cursor, ...) to drive the app over MCP, or a chat assistant beside it

Do not use this for: production apps with complex routing, custom auth, or non-Python frontends — Fast Dash is opinionated for the single-file-Python-function use case.

Install

bash
pip install fast-dash

The core pattern

python
from fast_dash import fastdash

@fastdash
def greet(name: str = "world") -> str:
    return f"Hello, {name}!"

# Serving on http://127.0.0.1:8080

That is the whole app. Open the URL, type a name, click Run.

How to approach a Fast Dash task

  1. Start from the user's function. If they don't have one, write the smallest function that captures their intent.
  2. Add type hints and defaults. This is where the UI comes from — int → number input, bool → checkbox, str with a list default → dropdown, etc. See references/components.md for the full table.
  3. Decorate with @fastdash. For more control (tabbed multi-function apps, multi-step pipelines), use the FastDash(...) class directly.
  4. Run and verify. The decorator starts a server immediately on import. For notebooks, pass mode="inline".

Common patterns

PatternSyntaxWhen
Single function@fastdashOne tool, one form
Multiple outputs-> (Graph, Graph) + mosaic="AB"Dashboard with several plots
Cascading inputsstate=depends_on("country", resolver)Dependent dropdowns
Multiple tools, one appFastDash([fn_a, fn_b], tab_titles=[...])Tabbed "apps" under one URL
Multi-step wizardFastDash(steps=[fn_a, fn_b, fn_c]) + from_step(prev_fn)Pipeline UX, one panel at a time
Streaming outputsyield partial results (or update("x", chunk)) + stream=TrueLLM / token-by-token / progress
Notebook rendering@fastdash(mode="inline")Jupyter
Wrap a custom componentFastify(dcc.Slider(...), "value")Any Dash component
Drive from an AI agent@fastdash(mcp_server=True) → agent connects to :8080/mcpHuman and agent use the same app
Agent-built formDynamicDash(callback_fn=..., mcp_server=True) + agent calls set_formForm fields decided at runtime
Chat assistant@fastdash(chat=True) on a yield-ing function, or chat=True, chat_model=... on a normal appChat UI / assistant beside an app

Full examples for each: references/patterns.md.

Type hint → component quick reference

HintComponent
strSingle-line text input (a long / multi-line default → text area)
str with default=[...]Dropdown, starting on the first option
int, floatNumber input
boolCheckbox
Literal["a", "b"]Dropdown
Annotated[int, range(0, 100)]Slider
listMulti-select (starts with nothing picked)
int with default=range(...)Slider, starting at the range start
datetime.dateDate picker
pd.DataFrame (return)Table
plotly.graph_objects.Figure (return)Plotly chart
PIL.Image.ImageImage upload / display

Full table with every supported hint: references/components.md.

Built-in components to import

Pass these directly as inputs= or outputs= when you want to override inference:

python
from fast_dash import (
    # Inputs
    Text, TextArea, PasswordInput,
    NumberInput, Slider,
    Switch, MultiSelect,
    DateInput, DateRange, ColorInput,
    Upload, UploadImage,
    # Outputs
    Graph, Image, Table, Markdown, Chat, Download,
)

For streaming and building custom UIs, also available:

python
from fast_dash import (
    Fastify,           # wrap any Dash component as a Fast Dash component
    depends_on,        # cascading input default
    from_step,         # multi-step pipeline data threading
    update, notify,    # push partial results / toasts during streaming
    dcc, dbc, dmc, html,  # re-exported: dash.dcc, dash_bootstrap_components, dash_mantine_components, dash.html
)
Show full SKILL.md (314 more words)Show less

Non-obvious things that will bite you

  • @fastdash starts the server on import. Put it in a if __name__ == "__main__": guard if the file is imported elsewhere, or skip the decorator and use FastDash(...).run().
  • Default Bootswatch theme= does not restyle Mantine chrome (v0.2.x). Only dark/light flips for known dark themes (CYBORG, DARKLY, SLATE, ...).
  • Don't reuse a single component instance across inputs and outputs — pass the class (inputs=Text) not an instance. Mutation surprises.
  • Output labels come from the return line of the source. REPL / exec contexts fall back to OUTPUT_1, OUTPUT_2. Pass output_labels=[...] to override.

Full list with reproducers: references/gotchas.md.

Decision tree

  • User has one function, simple form → @fastdash on the function, done.
  • User has one function, multiple outputs → @fastdash(mosaic="AB\nAC"), return a tuple of components.
  • User has multiple independent tools → FastDash([fn_a, fn_b], tab_titles=[...]).run().
  • User has a pipeline (step 1 output feeds step 2) → FastDash(steps=[fn_a, fn_b, ...]).run() with from_step(prev_fn) defaults.
  • User has dependent dropdowns → depends_on("parent_name", resolver) as a default value.
  • User wants streaming / token-by-token output (LLMs, progress) → yield partial results (or call update(name, data), name = the returned variable) + stream=True on the app.
  • User wants the app in a Jupyter notebook → add mode="inline".
  • User wants to not start the server immediately → use FastDash(...) class, skip .run().
  • User wants an AI agent to use the app → add mcp_server=True; the agent connects to http://localhost:8080/mcp and starts with describe_app(). Add backend="fastapi" (needs fast-dash[fastapi]) for real-time push.
  • User wants the agent to decide the form → DynamicDash(callback_fn=fn, placeholder=..., mcp_server=True); the agent calls set_form(specs=[...]).
  • User wants a chat assistant → chat=True (see references/patterns.md); an auto-built assistant needs pip install "fast-dash[agent]".

Before reporting complete

Run the app and verify it loads. If you can't open a browser:

  • check the console for tracebacks
  • confirm the port (default 8080) is free
  • for notebooks, confirm mode="inline" was set

If the user has dash[testing] installed, a headless smoke test is worthwhile. Otherwise, ask the user to verify the UI themselves.

© dkedar7, 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 3 other files (references) in plugins/fast-dash/skills/fast-dash of dkedar7/fast_dash.

  • SKILL.md
  • references/components.md
  • references/gotchas.md
  • references/patterns.md

Open the folder on GitHubat commit e87489a

Compare with similar skills

Fast Dash 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.

Fast Dash compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Fast Dash this skilldkedar7/fast_dash129—~1.9kAutomated safety check: PassMIT
Retentioneering Contributingretentioneering/retentioneering-tools925—~1.8kAutomated safety check: PassApache-2.0
Cao Contributingawslabs/cli-agent-orchestrator1.4k—~4.1kAutomated safety check: PassApache-2.0
Modern Pythonantoinebou12/uml-mcp105—~1kAutomated safety check: PassMIT
Upgrading Mwaa Environmentsaws/agent-toolkit-for-aws2.8k—~7.3kAutomated safety check: PassApache-2.0
Microsim Generatordmccreary/ibook-skills105—~11kAutomated safety check: PassNone

Similar skills

  • Retentioneering Contributing

    retentioneering/retentioneering-tools

    Help the user turn their Retentioneering ideas, friction reports, bug findings, or feature needs into high-quality upstream contributions: from capturing and validating the idea, through minimal…

    925 GitHub stars~1.8k tokensUpdated yesterday
    Data & AnalyticsAuto-check passed
  • Cao Contributing

    awslabs/cli-agent-orchestrator

    Official

    Contribute changes to the CAO (CLI Agent Orchestrator) codebase — the local dev loop, the CI gate map, and the pre-PR checklist.

    1.4k GitHub stars~4.1k tokensUpdated today
    DevelopmentAuto-check passed
  • Modern Python

    antoinebou12/uml-mcp

    Modern Python tooling and best practices using uv, ruff, ty, and pytest.

    105 GitHub stars~1k tokensUpdated today
    DevelopmentAuto-check passed
  • Upgrading Mwaa Environments

    aws/agent-toolkit-for-aws

    Official

    Upgrades an MWAA environment to a newer Airflow version — within 2.x, within 3.x, or across the 2.x-to-3.x boundary.

    2.8k GitHub stars~7.3k tokensUpdated today
    Data & AnalyticsAuto-check passed
  • Microsim Generator

    dmccreary/ibook-skills

    Creates interactive educational MicroSims, routing to the best-matched generator - p5.js, Chart.js, Plotly, Mermaid, vis-network, timelines, maps, Venn, causal-loop/feedback-loop diagrams (CLD)…

    105 GitHub stars~11k tokensUpdated today
    Data & AnalyticsAuto-check passed
  • Querying Indonesian Gov Data

    suryast/indonesia-gov-apis

    Query 57 Indonesian government APIs and data sources — BPJPH halal certification, BPOM food safety, OJK financial legality, BPS statistics, BMKG weather/earthquakes, Bank Indonesia exchange rates…

    172 GitHub stars~997 tokensUpdated today
    Data & AnalyticsAuto-check passed

Questions about Fast Dash

What does Fast Dash do?

Build a Fast Dash web app from a Python function. An agent skill from dkedar7/fast_dash. Fast Dash is an agent skill from dkedar7/fast_dash. Build a Fast Dash web app from a Python function.

When should I use Fast Dash?

Fast Dash fits situations like: the user wants to turn a function into an interactive app; add a UI to an existing function; build a dashboard / form / wizard; add a chat assistant to an app.

How do I install Fast Dash in Claude Code?

Run `npx skills add dkedar7/fast_dash --skill fast-dash -a claude-code`. Or copy the skill folder (plugins/fast-dash/skills/fast-dash in dkedar7/fast_dash) into .claude/skills/fast-dash in your project. Claude Code loads it when a task matches its description.

How do I install Fast Dash in Codex?

Run `npx skills add dkedar7/fast_dash --skill fast-dash -a codex`. Or copy the skill folder (plugins/fast-dash/skills/fast-dash in dkedar7/fast_dash) into .agents/skills/fast-dash in your project. Codex loads it when a task matches its description.

Can I use Fast Dash 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 dkedar7/fast_dash --skill fast-dash -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/fast-dash, .gemini/skills/fast-dash, .github/skills/fast-dash and .opencode/skills/fast-dash in your project.

What does Fast Dash need to run?

Going by SKILL.md and its folder, Fast Dash needs the command-line tools its instructions call (pip). Our summary lists: Python 3.

Does Fast Dash access the network?

SKILL.md contains no URLs. Its commands use pip, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Fast Dash 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 Fast Dash use?

Fast Dash 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 Fast Dash use?

About 1.9k tokens (SKILL.md is roughly 7.7k 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 4.2k tokens, read only when the agent opens those files.

What are the alternatives to Fast Dash?

Skills that share tags, products or a category with Fast Dash: Retentioneering Contributing (retentioneering/retentioneering-tools, 925 stars), Cao Contributing (awslabs/cli-agent-orchestrator, 1.4k stars), Modern Python (antoinebou12/uml-mcp, 105 stars) and Upgrading Mwaa Environments (aws/agent-toolkit-for-aws, 2.8k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Fast Dash?

dkedar7 (a GitHub user) maintains it in dkedar7/fast_dash, which has 129 GitHub stars. The repository was last updated on October 4, 2026.

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