Claude Code Skills for Tableau Developers

The single biggest jump in how well Claude builds Tableau things, for me, didn't come from a new model or a cleverer prompt. It came from skills. This guide is the Tableau-specific version: which skills actually help Tableau developers, how to install them, what the free TableauOps extension skill contains, and how to write your own for the standards your team already has.

If you want the general explanation first, I wrote what is a Claude Code skill. I won't repeat it here. The one-line version: a skill is a folder with a SKILL.md file that Claude Code loads when the task matches, so it starts the job already knowing your rules.

Why does Tableau work need skills more than most?

Because so much of Tableau's knowledge is unwritten, and the penalties for getting it wrong are quiet.

Claude knows JavaScript, React, D3, SQL and Python very well. What it doesn't walk in knowing:

• A .trex manifest has a fixed element order, and right-elements-wrong-order fails exactly like a missing element.
• Two Marks card tiles can't share an icon token. You find out with error ED626076 when you add the extension.
• A manifest that points at localhost works on your machine and nowhere else.
• Your team's naming convention for calculated fields, your LOD style, which projects are off limits, how you like refresh failures triaged.

Every one of those is a guess Claude has to make, and each wrong guess costs you a round trip: load, error, paste, patch, reload. A skill turns those guesses into rules it already has before the first line of code.

What does a skill change? A before and after

I ran the same extension build twice with Claude Code: same model, same prompt, once with the Tableau extension skill and once without. With the skill it took 1 minute 20 seconds. Without it, 8 minutes 33 seconds, most of that spent fixing manifest and API errors the skill prevents. Both runs are on the skill demo page, code and all, if you want to see the difference rather than take my word for it.

The pattern is the same every time:

Michael McCusker, a Tableau Tech Lead, put it this way after trying it: "I went from zero to a working dashboard in one initial prompt. I liked some of the standards that were baked in without having to discover them throughout, like creating 2 manifest.trex files for dev and prod."

Which Claude Code skills help Tableau developers?

Here's what I'd actually install or write, in order of payoff.

1. A Tableau extension skill

This is the one with the clearest win, because extensions are where Claude's guesses fail loudest. The free TableauOps extension skill covers:

• The .trex manifest rules for both dashboard and viz extensions, with separate dev and prod manifests from the start.
• Extensions API patterns that work: initializing first, reading worksheet data through the summary data reader, settings, configure dialogs, and Marks card encodings.
• The common build errors and their fixes, like FD722608 (a missing icon, elements out of order, or a -- inside an XML comment) and ED626076 (duplicate encoding icons).
• Local development and hosting, wired the way Tableau expects, plus a demo mode so the extension renders sample data in a plain browser tab while you build.
• A definition of done: no scrollbars at any pane size, a real empty state, a working configure dialog with theme, accent and size, and a hosted HTTPS manifest for sharing.

It arrives by email as a single SKILL.md. It's self-contained: every template and fix is inline, so Claude doesn't need anything else to use it.

2. A kit skill, when you're building more than one extension

Once you build three or four extensions, you'll want them to look and behave alike: one brand, one configure dialog, one way of handling empty states. The TableauOps Extension Kit is that, packaged: the rules, a working starter, runnable examples, reference guides and prompt recipes. Drop it into Claude Code, describe the extension, and it builds to the same standards every time. The finished extensions built that way are in the gallery.

3. Your own team standards skill

This is the one most Tableau teams are missing, and you can write it in an afternoon. More on that below.

4. Skills for the rest of the Tableau job

Extensions aren't the only place this works. Anything you keep pasting into chat is a skill waiting to be written: a workbook review checklist (see reviewing a Tableau workbook with AI), your REST API and TableauServerClient habits (see Tableau REST API automation with Claude), or your calculated field style (see Tableau calculated fields with AI).

How do you install a Claude Code skill?

A skill is a folder with a SKILL.md in it. Where you put the folder decides where it loads. From Anthropic's skills docs:

For the free extension skill:

mkdir -p ~/.claude/skills/tableau-extensions
# move the SKILL.md from the email into that folder
mv ~/Downloads/SKILL.md ~/.claude/skills/tableau-extensions/

On Windows, the same folder lives under your user profile: C:\Users\<you>\.claude\skills\tableau-extensions\SKILL.md.

If your whole team builds extensions in one repo, put it under .claude/skills/ in that repo and commit it. Everyone gets the same rules, and changes go through review like any other code.

How does Claude know when to use a Tableau skill?

From the description in the skill's frontmatter. Claude reads the descriptions of your installed skills and loads a skill when the task matches. You can also invoke one directly with /skill-name, for example /tableau-extensions.

That makes the description the most important line in the file. The extension skill's description names every way people ask for one: dashboard extension, viz extension, custom mark type, custom chart for Tableau, a .trex file, a KPI card. If your skill isn't firing, the description is almost always the reason. Make it describe the requests, not just the topic.

How do you write a Claude Code skill for your Tableau team's standards?

Start with the corrections you make most often. If you've told Claude "we don't use FIXED LODs on the executive data source" three times, that belongs in a skill. Here's a starter you can adapt:

---
name: acme-tableau-standards
description: >
  Use when writing or reviewing Tableau calculated fields, LOD expressions,
  table calculations, field names, or workbook structure for Acme. Trigger on
  "calc", "calculated field", "LOD", "FIXED", "table calc", "rename fields",
  or any Tableau workbook review.
---

# Acme Tableau standards

## Naming
- Measures: Title Case with the unit last, e.g. "Revenue USD", "Margin %".
- Booleans start with "Is" or "Has", e.g. "Is Returned".
- Never rename a field that is used by a published data source without
  listing every workbook that depends on it first.

## Calculations
- Prefer INCLUDE and EXCLUDE over FIXED on published sources, because FIXED
  ignores dimension filters unless they are context filters.
- Every calculated field gets a one-line comment starting with //
  explaining the business rule, not the syntax.
- Divide with ZN() or an IF guard. No raw division by a SUM.

## Review checklist
1. Any calc duplicated under two names?
2. Any FIXED LOD on a sheet with dimension filters that aren't in context?
3. Any field named with a default like "Calculation1"?

## Off limits
- Never suggest publishing to the "Certified" project. Hand back the change
  and let a human publish it.

Three tips from writing a lot of these:

1. Write rules, not essays. Short imperative lines beat paragraphs. Claude follows "never X, because Y" very reliably.
2. Put the error text in. If a rule exists because of a specific error, quote the error. That's how Claude connects an error you paste to the fix.
3. Version it. A skill in a repo gets better every time someone fixes a mistake and adds the rule.

Skills, CLAUDE.md or MCP: which one do you need?

They solve different problems, and Tableau work usually wants all three.

A skill tells Claude how to do the job. An MCP server lets it reach the systems. I cover the MCP side in Tableau MCP server: connect Claude to Tableau, and the wider tool landscape in the best AI tools for Tableau developers.

What's the best way to test a Tableau skill?

Run the same prompt twice, once with the skill installed and once without, and compare. That's exactly how I timed the extension skill. Count the round trips: how many times did you have to paste an error back? A good skill gets that to zero or one on the builds it covers.

Then keep a short list of prompts that used to fail, and rerun them whenever you edit the skill. When something new breaks, add the rule, rerun, and commit.

Your next step

Get the free Tableau extension skill, drop it in ~/.claude/skills/tableau-extensions/, and run the lollipop prompt from build a Tableau extension with Claude. If you'd rather see the result before installing anything, build one in Studio in your browser. More guides are on the Tableau + AI hub.