I Let Generative AI Build an Entire Tableau Workbook (An Experiment)
Published: 2026/10/17
Last updated: 2026/10/17This article is about an experiment in having generative AI, specifically Claude Code, build a Tableau workbook from scratch, and about what I came to feel through that experience.
I had two motives for trying this.
The first was technical curiosity. In September, Tableau released a plugin for Codex, and it included a well-organized workbook schema and references. I wanted to see how much of workbook creation can be handed to generative AI today.
Tableau's announcement on X:
The second was a follow-up to what I wrote in my recent article, Thinking About the AI🤝BI Worldview (in Japanese).
Granting that BI platforms are still needed, I don't think it's quite right that converting things into a platform's own format keeps costing so much effort.
For example, generative AI can give you something in HTML almost instantly, yet sharing it across an organization still means a person has to spend time rebuilding it by hand. It feels like effort that could go into the analysis itself.
To take direct advantage of the speed, efficiency, and quality that generative AI brings, I wanted to explore building Tableau workbooks with it.
For the subject of the experiment, I used Workout Wednesday 2026 Week 40, a challenge I was in charge of setting.
I used generative AI for every step of building the challenge workbook. And I got it to a publishable state with almost no editing in Tableau Desktop.
There turned out to be a lot I wanted to say, so I split the article into two parts.
The first part shows that most of workbook creation can be left to AI, and why that matters. It's for readers who want to try it right away.
The second part walks through how I got there, and what working with AI actually looked like.
The skills and other AI assets I used in this experiment are published below.
It could also be a good idea to have your AI read this repository and explore it interactively.
With that, let's explore what it looks like when AI takes on much of the building.
The Bottom Line: Most of the Work Could Be Left to AI
Beyond that, the result was faster and at a lower cost than building it by hand, and the workbook came out in a shape that's easy for people to revise later.
What I had it build was a mobile dashboard that answers Yes / No to whether sales and profit for a selected week were better than usual, and better than the same period last year.
We agreed on the challenge in HTML first, then had it rebuilt as a workbook.
On the left of the figure is the dashboard I had AI make in HTML; on the right is the Tableau dashboard AI generated. I fine-tuned things like font sizes through conversation, so it isn't a perfect reproduction of the HTML. But in essence, the experience was "something AI made quickly gets reproduced quickly as a workbook."
The inside of the workbook is also organized so that a person can read it and rework it.
If you open the actual challenge workbook, you'll see that it also achieves the kind of organization for maintainability I wrote about in this article (in Japanese).
Calculated fields are grouped by role into folders, and unneeded calculations were deleted along the way. The result is a fairly clean workbook.
AI handled everything from the visual prototype to generating the workbook XML, publishing to Tableau Cloud, checking the render, and cross-checking the values.
My part was only to say what I wanted (what it's for, which data, and how to show it) and to check the finished product at the end.
Once the workbook was assembled, each round trip, from "here's what I want" or "change this" to a checked render, took just 1–2 minutes. (The very first build took longer.)
In Tableau, as elsewhere, changing one thing rarely means changing only one spot.
For example, say you decide "we don't need this data shown anymore" and want to remove one view. That brings along tasks like these:
Deleting the calculated fields that view used
Checking how the calculated fields' dependencies are organized (checking "is it really OK to delete this?")
Deleting the sheet (if needed)
Deleting text related to the displayed data
Publishing and checking the render
etc...
I could leave all of this to AI as well.
The Cost Is Reasonable, Too
Even granting that AI works well, you'll want to know what it costs.
In short, given an HTML file with agreed requirements and an agreed look, the cost of reproducing it as a workbook came down to about $5.
I say "came down" because this experiment went through trial and error to get there. Please read it as: assuming enough AI assets are already in place, this is roughly what building this dashboard costs.
Note: what the ~$5 rebuild involved
- I handed over only two things: the requirements document and the HTML whose look had been agreed
- No person was involved along the way; AI on its own autonomously ran five rounds of: write the workbook → publish → check the render as an image and fix
- Publishing failed in round 1; from round 2 on, it progressed in a form that rendered
- Small visual differences remained, such as how tooltips and legends looked, so a separate finishing conversation is still neededBy my rough estimate, building a workbook like this by hand can take hours, sometimes days. Getting a solid first version that reflects expert know-how for around $5, and spending the saved time on the design itself, felt well worth it to me.
Summary of the First Part
That's where I think things stand now: given enough knowledge and references, AI can produce a well-built workbook faster and at a lower cost than building it by hand, and fairly reproducibly.
I believe the value lies here: with AI as a collaborator, it could become easier for people less familiar with Tableau Desktop to take part in building and fixing Tableau dashboards meant to be shared across an organization.
I also came away feeling that the gap I raised at the start, from an HTML prototype to a workbook, can likely be crossed with AI's help.
Agree on the broad shape of the design in HTML, and leave the conversion to the BI platform to AI. Leave the fixes that come up while running a dashboard to AI as well. In the Tableau world, I suspect more Creators will find themselves working this way.
I may spend less of my own time on the mechanics of building in Tableau, and more on the questions of "why, which data, and how to show it."
This is just my impression from this one experiment, but it felt like a good change. Spending less time on hands-on work and more time thinking about what kind of dashboard to build was a very positive experience. I like spending time on purposes and the goals we want to reach.
Whether it's my WOW challenge-building repository, Tableau's official plugin, or anything else, please do try having AI build a workbook. Let's accelerate AI🤝BI. I'd really encourage you to give it a try. It's fun!
The Second Part: Getting to the Point Where AI Could Take It On
What I wrote in the first part is the story after the skills and references were in place. Getting there took trial and error. The first workbook AI made could be opened in Tableau, but it was far from the model.
In the second part, I'll split the journey into these four pieces:
What I borrowed from the Tableau plugin, and how far that got me
Making it possible for AI to check renders on its own
Filling in the gaps with best practices and practical know-how
How things were built once the skills and references were in place, and how my role changed
It started with an HTML prototype, and went back and forth between generating the workbook and changing the look in HTML, before finally arriving at the finished dashboard.
The Tableau Plugin, and What I Borrowed From It
Note on the Tableau plugin
What I describe about the plugin is based on information as of the time of writing (October 11, 2026).
Please check the GitHub repository for the latest information.In Claude Code and similar tools, a plugin is a mechanism that bundles skills, MCP servers, hooks, and so on into a single folder so they can be installed together. Plugins are generally installed from a list called a marketplace.
Plugin references:
Plugins overview (Claude Code Docs)
Package your plugin (OpenAI Codex Docs)
For Tableau, Salesforce has published tableau-plugin on GitHub. It's a plugin for Codex that connects to Tableau's MCP server. It has skills for finding Tableau content, rendering views, and building and fixing workbooks.
The workbook-building skill (tableau-workbook-authoring) covers building a workbook from chart templates or by hand-editing XML, through validation, to publishing and rendering via MCP.
In this experiment, I borrowed the materials for writing workbook XML from this skill. I didn't install it into Claude Code as a plugin; instead, I copied these files into my own repository and used them from my own skills.
Specifically, I used the following materials:
Workbook schemas for each Tableau version (XSD; 2025.1 through 2026.2 are bundled this time)
Syntax examples for each workbook element (JSON that abstracts the XML)
A script that validates a workbook against the XSD
Note: why I didn't use the Tableau plugin as-is
It would have been nice to use it as-is...
The Tableau plugin is built to publish workbooks and check their renders through the MCP server Tableau provides. However, publishing via MCP may not be available depending on prerequisites such as site settings, and in my environment Tableau MCP alone couldn't complete the job.
Even if you run the MCP server yourself, publishing apparently requires enabling the feature and also setting up Amazon S3. See the following article for details (in Japanese).
https://zenn.dev/cavernaria/articles/ed1060c67f26fd
Setting up these prerequisites on my end was difficult, and publishing itself is possible through the REST API, so this time I had AI call the REST API instead of using Tableau MCP.A Workbook That Opened, But...
At first, I started from a skill I'd been using for a while (one that writes differences into a template workbook), with workbooks from past challenges as models.
Once I added a mechanism to check the structure against the plugin's schema (XSD), it quickly got as far as a workbook that opened in Tableau Desktop.
However, as you can see by comparing it with the HTML model on the left, the look is completely different. Not only that, some parts didn't render correctly.
The lower charts were blank. The cause was the apostrophe in "last year's" inside a calculation, which cut the string off there
Amounts were shown 1000 times too large, and the color of this week's bar was reversed
Both happened even though the XSD validation passed.
XSD only checks structure, so errors in formulas, or missing declarations that Desktop silently fills in, don't show up until you open and render the workbook.
The plugin materials I borrowed (the schema, syntax examples, and validation script) could only check structure, so my first impression was that I'd have to add everything beyond that myself.
There was one more problem, separate from rendering.
The workbook was built by brute force, creating each display element one calculated field at a time. It kept the same calculations separately for sales and profit, made even the start and width of background bands into calculated fields, and built the Yes / No text and notes separately for each of the four questions. As a result, it had ballooned to 87 calculated fields.
That makes it hard for people to keep revising the workbook from here, and hard to check whether it's built correctly.
So from here on, I gave AI tools to check its own work, and expanded what AI knows.
Letting AI Check Renders on Its Own
At first, I fixed rendering problems one by one through conversation with AI. I would open it in Desktop and point out what looked wrong. AI would look for the cause and fix the XML. For elements it didn't know how to write, I would do the same operation in Desktop, save, and have it copy that XML. That was the cycle.
In place of the plugin's MCP path, I built this myself on the Tableau Cloud REST API.
I made it so AI could run the whole sequence end to end: validating the fixed workbook, publishing to Tableau Cloud, and fetching the rendered image. In short, I made it possible for AI to check what it made by itself.
Giving It Best Practices and Practical Know-How
Even once it could check renders, that alone doesn't get you beyond "it can make a workbook that works."
Best practices and knowledge about Tableau workbooks and building visualizations had to be handed to AI separately. I filled these in by having it build, fail, and repeat. (There are probably more efficient ways to go about it, but as an experiment I was fully prepared for trial and error...)
As an example, let's revisit the "87 calculated fields built by brute force" story from earlier. Once it had been given this knowledge and these practices, things were organized like this.
The same calculations for sales and profit were merged into one set, background bands and average lines were drawn without calculated fields, and things that were no longer needed were removed. The remaining 24 were split into 5 folders by role.
My Role Once AI Could Take On the Building
By the finishing stage, the back-and-forth with AI had become much lighter. Each round took 1–2 minutes, so I could throw out an instruction based on gut feeling, look at the render, and then decide what to do next.
Summarized, the actual exchanges looked like this.
Partway through, I started using HTML to agree on the look.
I had AI prepare a page with the agreed HTML design and the dashboard rendered in Tableau side by side, and we talked while looking at the same screen.
Since the workbook could be published to Tableau Cloud, what it built was fetched as an image.
Once the overall shape was set, small fixes were faster done by having it edit the twb. Only when changing how something is shown (such as switching chart types) did we make a proposal in HTML first and decide together.
Even then, AI was the one producing the actual proposals; I was only responsible for requests and judgment.
Once AI could act this autonomously, the questions occupying my head started to change.
When I couldn't yet leave the building to AI, a fair amount of my thinking went to hands-on matters: how to edit the workbook, what to fix so it would open, and so on.
By the end, that had turned into time spent looking at what was built and asking whether this way of showing it is right, whether this is the right data, and what value this dashboard provides.
Tableau operations stop being a hurdle, and you can build by simply following what you want to see. Once AI can take on most of workbook creation, I think this is where the big value lies.
Through this experiment, I got a taste of that.
Could more people across an organization take part in BI, even without deep Tableau experience? Could we cross the gap I raised at the start? I felt that kind of excitement.
Closing
So that was my experiment in leaving Tableau workbook creation to AI. Once the materials borrowed from the plugin were combined with skills and references written up from failures and decisions, I got to the point where most of the building could be handed off.
This was one dashboard. I think the real value comes from repeating this across many dashboards and workbooks, and feeding what we learn back to AI.
Each time you build, write the failures and decisions back to the AI side. The next build can start from that scaffolding, so the range you can hand off should keep widening the more you do it.
If you have any questions, please reach out on X or LinkedIn. Thanks for reading!