When you ask an AI coding assistant to "build a Streamlit dashboard," it does its best. But the assistant is working from general knowledge that may be months or years out of date.

Here's what that looks like in practice:

Beyond deprecated APIs, the AI might skip caching entirely — meaning your app re-runs expensive queries every time a user clicks a filter instead of reusing results it already fetched. Or it might initialize session state with verbose if/else blocks instead of the one-liner setdefault() pattern.

Agent skills fix this by giving your AI assistant specialized, up-to-date knowledge about Streamlit development. Think of them as reference guides that your AI reads before writing code. Instead of guessing how to build a chat interface or configure a theme, the AI loads a skill that contains the exact patterns, code examples, and guidelines for that task.

The streamlit/agent-skills repository is an open-source collection of 17 specialized skills for Streamlit development. They cover everything from building dashboards and chat UIs to connecting to Snowflake and creating custom components. The skills work with any AI coding assistant that supports the agent skills format — including Claude Code, Cursor, and Cortex Code (where they come pre-installed).

This guide walks you through installing the skills, understanding what each one does, and using them to build real apps. No prior experience with agent skills is required.

Here's a schematic summary of the Streamlit app creation process using the agent skills:

Two working Streamlit apps — a dashboard with KPI metrics and charts, and a chatbot with streaming responses — built with the help of agent skills.

Before we dive in, let's understand what agent skills actually are and why they matter.

AI coding assistants are trained on massive amounts of code, but their knowledge has a cutoff date. When you ask your AI to build a Streamlit app, it might generate code based on patterns that were correct a year ago but are outdated today.

The deprecated API in the Overview is just one example. Here are other common issues with unaided AI-generated Streamlit code:

An agent skill is a folder containing a SKILL.md file and optional supporting resources:

When you ask your AI to build a Streamlit app, it reads the relevant SKILL.md file and follows the instructions inside. This means the AI uses current APIs, proper caching patterns, and Streamlit-specific best practices — because the skill told it exactly what to do.

You don't need to tell the AI which skill to use. The parent skill (developing-with-streamlit) acts as a router that matches keywords in your prompt to the right sub-skill. The diagram below shows this flow end-to-end: your prompt enters on the left, the parent skill identifies relevant keywords and fans out to one or more sub-skills, and the AI uses those skills to generate code that follows current best practices.

Here's how it works in practice:

If your prompt touches multiple areas — like "build a dashboard with a sidebar and charts" — the parent skill loads multiple sub-skills at once so the AI has all the code examples and guidelines it needs.

Installation depends on which AI coding assistant you use. Pick your tool below.

Good news — the skills are already bundled with Cortex Code under the name developing-with-streamlit. No installation needed. You can verify that they're available by running:

Look for developing-with-streamlit under [BUNDLED].

Copy the skill folder to your Claude Code skills directory:

Copy the skill folder to your Cursor skills directory:

The same developing-with-streamlit folder works with any assistant that supports the agent skills format.

The developing-with-streamlit skill contains 17 specialized sub-skills. Here's what each one does and when it activates.

You don't need to memorize this table. Just describe what you want, and the parent skill routes to the right sub-skill automatically.

Let's put the skills to work. We'll ask our AI assistant to build a dashboard and see how the skills improve the output.

Open your AI coding assistant and type:

When the AI receives this prompt, the parent skill routes to three sub-skills:

1. building-streamlit-dashboards — Provides the KPI card pattern using st.metric(border=True) and st.columns
2. displaying-streamlit-data — Provides chart patterns using st.line_chart with proper data formatting
3. optimizing-streamlit-performance — Ensures @st.cache_data is added to the data loading function

The AI generates something like this:

Here's what changed compared to what an unaided AI would generate. Each comparison below shows the "without skills" version first, followed by the "with skills" version:

Data loading — without vs. with skills:

Caching tells Streamlit to store the result of a function so it doesn't re-run every time the page refreshes. The @st.cache_data line below is a Python decorator — a one-line annotation you place above a function to change its behavior.

Page config — without vs. with skills:

Date filter — without vs. with skills:

Each change is small on its own, but they compound fast. An app without caching feels sluggish. An app without bounded date inputs breaks when a user selects a date in the future like December 2030. An app without layout="wide" wastes half the screen on a dashboard. The skills prevent all of these issues because the AI follows proven patterns instead of improvising.

Save the code as app.py and run:

You should see Streamlit start up in your terminal:

Open http://localhost:8501 in your browser. You should see a dashboard with three KPI cards, a line chart, and a sidebar date filter — all working out of the box.

Now let's build something completely different — a chatbot with streaming responses.

The parent skill routes to:

1. building-streamlit-chat-ui — Provides the st.chat_message + st.chat_input pattern with message history
2. using-streamlit-session-state — Ensures proper initialization with st.session_state.setdefault()

Let's look at the specific patterns the skills provided:

Session state initialization:

Both work, but setdefault is more concise and is the pattern the skills teach.

Streaming with st.write_stream:

The st.write_stream function handles all the complexity of displaying streaming text. It replaces several lines of manual placeholder logic with a single call.

Chat message pattern:

This assigns the input to prompt and checks if it's non-empty in one line.

Type a message and watch it stream back word by word. Click "Clear chat" in the sidebar to reset the conversation.

Every Streamlit app starts with the default theme, but the skills include 8 ready-made theme templates you can apply instantly.

The creating-streamlit-themes skill provides these templates:

To apply a theme, ask your AI assistant:

The creating-streamlit-themes skill activates and the AI creates a .streamlit/config.toml file:

That's it. Restart your app and the theme is applied. No CSS, no custom components — just a config file.

Streamlit reads config.toml on startup and applies these five settings (four colors and a font) to every widget, chart, and layout element. This means a single file controls the look of your entire app — buttons, sliders, DataFrames, charts, sidebar, and text all inherit from these settings automatically.

Streamlit supports both light and dark modes. The theme in config.toml sets the default, but users can toggle between modes from the app menu (the "⋮" icon in the top right corner, then Settings).

If you want to force a specific mode, add:

The theme templates also include Google Font configurations for a more polished look. Ask your AI:

The skill knows to configure the font in the theme settings for a clean, professional appearance.

Sometimes you don't want to start from scratch. The skills include 9 ready-to-use app templates that give you a working starting point.

Local Templates (6):

Snowflake Templates (3):

Ask your AI assistant:

The AI reads the template from the skills directory and creates your project files. Templates include sample data so you can run them immediately without setting up a database.

If your data lives in Snowflake, the connecting-streamlit-to-snowflake skill teaches the AI how to set up the connection properly.

The AI creates two files:

.streamlit/secrets.toml.example (rename to secrets.toml and fill in your credentials):

app.py with a Snowflake connection:

1. st.connection("snowflake") — The modern way to connect. The skill prevents the AI from using older patterns like snowflake.connector.connect() directly, which requires more boilerplate code and doesn't integrate with Streamlit's caching or secrets management.

2. @st.cache_data(ttl=600) — Caches query results for 10 minutes. Without this, every widget interaction would re-run the query.

3. Parameterized queries — When user input is involved, the skill teaches the AI to use parameterized queries instead of f-strings, which prevents SQL injection:

4. Secrets in .streamlit/secrets.toml — Credentials stay out of your code. The skill also creates a .example file so you know what to fill in.

One gotcha the skill handles: when you query Snowflake, pandas DataFrames come back with UPPERCASE column names. So SELECT order_id FROM orders returns a column named ORDER_ID, not order_id. The skill ensures the AI references columns in uppercase.

You've learned how agent skills transform your AI coding assistant from a general-purpose code generator into a Streamlit specialist. By loading domain-specific knowledge about current APIs, caching patterns, and design best practices, the skills ensure your AI writes Streamlit code that works correctly from the start.

Now that you have the skills installed, here are concrete things to try:

1. Swap in real data — Take the dashboard you built and replace the sample data with a live Snowflake query using st.connection("snowflake")
2. Combine apps — Ask the AI to "add a chat sidebar to my dashboard" and watch the routing load both building-streamlit-chat-ui and building-streamlit-dashboards simultaneously
3. Contribute a skill — The streamlit/agent-skills repository accepts pull requests. If you find a pattern the skills don't cover, add it

Documentation:

AI Coding Assistants: