<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Datacooper on Medium]]></title>
        <description><![CDATA[Stories by Datacooper on Medium]]></description>
        <link>https://medium.com/@imgwho?source=rss-818a0f4fa3b1------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*W-NGRwzdmxSgeVxnX-P3rA.png</url>
            <title>Stories by Datacooper on Medium</title>
            <link>https://medium.com/@imgwho?source=rss-818a0f4fa3b1------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 14:59:18 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@imgwho/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Generating Tableau Dashboards with Code: How I Had AI Help Me Solve Workout Wednesday]]></title>
            <link>https://medium.com/@imgwho/generating-tableau-dashboards-with-code-how-i-had-ai-help-me-solve-workout-wednesday-2084c9b2cfdf?source=rss-818a0f4fa3b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/2084c9b2cfdf</guid>
            <dc:creator><![CDATA[Datacooper]]></dc:creator>
            <pubDate>Tue, 03 Nov 2026 01:35:36 GMT</pubDate>
            <atom:updated>2026-11-03T01:35:36.871Z</atom:updated>
            <content:encoded><![CDATA[<h3>1. I’ve Been Building a Tool to Generate Tableau Dashboards with Code</h3><p>Anyone working with Tableau is probably familiar with Workout Wednesday, or WoW. I’m no exception. Usually, we connect to data and set up charts in Tableau Desktop. But I’ve been building an open-source tool called <a href="https://github.com/aidatacooper/cwtwb">cwtwb</a>, aiming to generate .twb and .twbx files through Python code to build Tableau dashboards.</p><p>A .twb file stores the setup for data connections, fields, charts, and dashboards, while a .twbx packages those definitions together with data extracts and other assets. cwtwb wraps common setup steps into code functions, letting scripts build these structures without having to assemble the underlying XML (the markup language Tableau workbooks use) by hand from scratch for every single case.</p><p>Still, whether a tool can generate a few small examples and whether it can handle real-world challenges are two very different things that need separate verification. Complex table calculations, parameter actions, dual-axis charts, layouts, and formatting can all expose gaps in the existing APIs. I needed concrete problems with reproducible baseline results to pinpoint what the tool was still missing.</p><p>If an AI could read the challenge requirements, call cwtwb to generate a dashboard, and update the code based on verification results, these real-world cases could test two things at once: the tool itself, and the workflow of using it. I later gathered all these analysis, build, and verification records in the <a href="https://github.com/aidatacooper/wow-tableau-problem-solving">wow-tableau-problem-solving</a> repository.</p><p><a href="https://datacooper.com/zh-CN/blog/building-tableau-dashboards-with-ai-wow-cwtwb">Chinese version</a></p><h3>2. A Few Months Ago, I Found Useful Material to Test the Tool</h3><p>A few months ago, I came across Donna Coles’s technical blog (<a href="https://donnacoles.home.blog/">https://donnacoles.home.blog/</a>).</p><p>She has steadily documented her solutions to WoW challenges on her blog. What drew me in was that, beyond the final charts, she explains the thinking behind the calculations, how fields are configured, and the step-by-step process of solving each challenge. While the community challenges are designed by different authors, Donna shares her own solutions along with reference workbooks.</p><p>Looking across these materials, I saw several sources of information that complemented each other:</p><ol><li><strong>Context and business requirements</strong>: Clearly explaining the analytical problem the challenge is trying to solve;</li><li><strong>Detailed walkthrough steps</strong>: Covering the formula logic for key calculated fields, the exact compute-using directions for table calculations, and the level of detail in the view;</li><li><strong>Publicly downloadable reference workbooks</strong>: Completed workbooks published on Tableau Public;</li><li><strong>Extractable raw data</strong>: Embedded data sources within the workbooks, or clean data inputs that can be unpacked locally.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*AsU-YNDyb6GLYs7q.png" /></figure><p><em>Figure 2–1: Mapping between test materials and datasets</em></p><p>I realized this was a helpful collection of materials to test cwtwb. With just a screenshot, you often have to guess the calculation logic. Here, with context, the problem statement, walkthroughs, and reference workbooks, the AI has source material to read, and I have a solid basis to check whether its output is correct. Of course, some blog posts or workbooks are missing, so the entire archive cannot be treated as ready-to-run cases off the shelf.</p><h3>3. I First Had AI Tackle One Challenge, Only to Realize “Getting It Done” Means Many Things</h3><p>One specific attempt was the “Donut Calendar,” designed by Luke Stanke with a comprehensive walkthrough by Donna.</p><p>The visual structure of this challenge is quite intricate:</p><ul><li>Vertically broken down by Region, and horizontally laid out as a calendar grid of Order Dates;</li><li>If all orders for that day are fully shipped, the cell displays a green checkmark;</li><li>If only partially shipped, a compact donut chart shows the percentage of shipped orders;</li><li>The far right side of the dashboard features a summary KPI card.</li></ul><p>At the time, I asked the AI in Antigravity to attempt this challenge. It reported that the workbook had been uploaded successfully. But when I opened Tableau Cloud, I saw a blank screen, with fields like Fully Shipped? throwing errors. The task had to continue into debugging, cross-referencing, and rebuilding.</p><p>Later on, I asked a follow-up question: was this file built from scratch using cwtwb, or was it modified from the author&#39;s reference workbook? My explicit requirement at the time was:</p><blockquote><em>[Translated] I required this to be written from 0 to 1 with cwtwb, otherwise it’s meaningless, so please redo it.</em></blockquote><p>Allowing direct copying would have defeated the purpose of my test. Copying an existing block of XML doesn’t prove that cwtwb can construct such charts on its own; instead, it obscures shortcomings in the library&#39;s API.</p><p>Therefore, I established clear boundaries for development and testing:</p><ol><li><strong>Permitted inputs</strong>: During the analysis phase, the AI may read Donna’s blog posts, examine the visual design of the reference workbook, and extract locked raw data inputs (such as .hyper files);</li><li><strong>Prohibited methods</strong>: When writing the actual build scripts, copying or modifying the reference workbook as a base template is not allowed;</li><li><strong>Must start from scratch</strong>: All build scripts must start with TWBEditor(&quot;&quot;) from a blank canvas, relying only on calling cwtwb&#39;s public APIs to step-by-step create fields, assemble data sources, configure marks cards, and build worksheet and dashboard layouts.</li></ol><p>Subsequent case scripts followed this build-from-scratch approach. Below are the author’s original image and the historical reproduction. While they match in parts of their proportions and marks, differences remain in titles, dimensions, whitespace, and positions with missing data. They help illustrate this attempt, but do not replace full acceptance; nor did earlier cases necessarily satisfy all conventions established later.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*C79YtZZxSiAF_vuv.png" /></figure><p><em>Figure 3–1: Reference solution shown in Donna Coles’s blog (author’s original)</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bDof8YempVUn7my8.png" /></figure><p><em>Figure 3–2: Replicated version generated from scratch by build scripts (historical replica)</em></p><p>This attempt made me realize that in code generation, “getting it done” cannot simply mean that the terminal exited with zero errors — we need automated verification across multiple angles to know if the result actually works.</p><h3>4. To Stop Checking Everything by Eye Every Time, I Began Automating Verification into Code</h3><p>These attempts got me thinking: if I had to open the file, compare numbers, and visually inspect the dashboard by hand for every single challenge, sustained progress would be impossible. So I gradually turned these repeatable checks into software scripts; loading issues discovered later further prompted me to add Tableau Desktop verification.</p><p>In the test repository, each case directory contains three files:</p><ul><li>case.yaml: Records the case metadata, the SDK (software development kit) version or commit hash used, the list of acceptance IDs, and the SDK outcome (pass, workaround, or blocked);</li><li>build_replication.py: Code that executes the build starting from an empty workbook;</li><li>verify_replication.py: An independent verification script that relies on none of the builder&#39;s internal state.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gn4Ei523rEbh7Lbq.png" /></figure><p><em>Figure 4–1: Single-case acceptance workflow and file structure</em></p><p>I divided the checks into several categories, with each drawing conclusions only on what it actually covers:</p><pre>[Build Artifact] <br>   │<br>   ├─► 1. Static structural checks (validate_iteration.py: XSD Schema / tag order / reference validity)<br>   │<br>   ├─► 2. Independent logic verification (verify_replication.py: reads Hyper and TWBX, recalculates metrics)<br>   │<br>   ├─► 3. Real client verification (build_and_check.py: invokes local Desktop and parses process logs)<br>   │<br>   └─► 4. Cloud image and data export (capture_case_cloud.py: exports images and CSVs under specific parameters)</pre><p>Independent verification also had to be grounded in data. The verification script for the Rosling case reads the locked Hyper input, independently aggregates facts for country, year, income, life expectancy, population, and region, and then checks the corresponding definitions inside the workbook. It does not import the build script, nor does it read the author’s workbook for answers. Some cases also compare independent calculation results against exported CSVs; specific coverage depends on the individual code and evidence.</p><p>Among these checks, a few details warrant explanation:</p><p>First, <strong>passing the static XML Schema (XSD) does not mean Desktop will load successfully</strong>. In past checks, there were cases where structural validation passed but Desktop still refused to open the file — due to missing application-level feature flags or other structural prerequisites. Static schema rules simply do not cover all client requirements.</p><p>Second, <strong>how do you determine whether a workbook loaded successfully from the logs?</strong></p><p>Rather than relying on fragile GUI automation that is prone to interference from window focus, language differences, and DPI scaling, it is far more dependable to parse the structured JSON Lines logs that Tableau Desktop writes locally.</p><p>In these logs, each line is an independent JSON object containing several fixed fields:</p><ul><li>ts is a millisecond-precision ISO 8601 timestamp used to filter new records generated after launch;</li><li>pid is the OS process identifier used to tell different instances apart;</li><li>k is the event name (key);</li><li>v is the event payload (dictionary or string);</li><li>args is typically the command parameter string nested within v.</li></ul><p>While sev (severity) and a (additional metrics like elapsed time and depth) frequently appear, they do not participate in the final verdict. Only ts, pid, k, and the contents of v (error commands are typically in v.args) are actually evaluated.</p><p>In our test logs, a simplified successful record appears with a dedicated event key and an empty payload:</p><pre>{&quot;ts&quot;:&quot;2026-10-08T19:23:34.306&quot;,&quot;pid&quot;:14528,&quot;k&quot;:&quot;end-workspace.load-workbook&quot;,&quot;v&quot;:{}}</pre><p>Conversely, failure records are not assigned a dedicated event key. Instead, they appear as generic command invocations with error details embedded inside v.args:</p><pre>{&quot;k&quot;:&quot;begin-commands-controller.invoke-command&quot;,&quot;v&quot;:{&quot;args&quot;:&quot;tabdoc:show-detailed-error-dialog error-code-id=\&quot;3538475634\&quot; ... error-short-message=\&quot;An error occurred while loading the workbook...\&quot; ...&quot;}}</pre><p>Detection is therefore asymmetrical: success requires an exact match on k == &quot;end-workspace.load-workbook&quot;, whereas failure requires substring searching for show-detailed-error-dialog within serialized v. In evaluation precedence, FAIL takes highest priority—the moment an error dialog signature is detected, the run is immediately marked as failed.</p><p>If the timeout elapses without matching either signature, the result falls into UNKNOWN. In real-world debugging, an UNKNOWN verdict can stem from various external causes: an unactivated Tableau 2026.1 installation stalling on the registration page, a secondary launch forwarded to a pre-existing instance, an interrupted process, or no definitive result before the timeout. Our rule is to retry; if the outcome remains ambiguous, the process stops and marks the check as blocked. We must never mischaracterize an UNKNOWN as a &quot;definitively corrupted workbook,&quot; which would obscure environment-level or lifecycle issues.</p><p>When writing filtering rules, avoid searching for broad keywords like error or license. Real logs show that entries like connector-plugin-error also appear in successful runs, while JobProxy licensing records are routinely logged during normal starts; only specific dialog signatures constitute valid check points.</p><p>Furthermore, the completion event of the DOM parsing stage, end-workbook-dom-loader.load-workbook-dom, does not equal workspace load completion. When a workbook harbors deeper flaws in its setup, DOM parsing still finishes cleanly, only for Desktop to pop an error dialog tens of milliseconds later. Only progressing through parsing to the workspace load boundary confirms success.</p><p>Additionally, Tableau uses multiple processes and rotates logs automatically on startup (sprawling across log.txt, log_bk.txt, log_1.txt, etc.), mixing events from different processes together. The verification script must scan all log*.txt files, finding the target pid via timestamp and the startup record containing argv[1] and the workbook filename.</p><p>Why can’t we inspect process exit codes directly? Tableau Desktop is a persistent GUI application; when workbook loading fails, it remains open with an error dialog rather than exiting, so an exit code alone does not establish the load result.</p><p>I should point out that this log result only confirms Tableau Desktop opened and parsed the workspace without crashing. It doesn’t guarantee that the layout looks right, nor that the numbers are calculated accurately. You can rerun this verification check with: python scripts/desktop/build_and_check.py iterations/&lt;case&gt; --sdk-src &lt;cwtwb-worktree&gt;/src Here, the --sdk-src parameter points to the local development Git worktree (a separate folder linked to the same repository) of our SDK (software development kit) source code. This lets us test fixes directly against test cases without having to package or publish a test release first.</p><p>Finally, these rules of thumb are just what we observed locally on our own setup (specifically Tableau 2026.2). They aren’t a “universally definitive” rule across every version. If a future Desktop update changes the internal names in the logs, we will need to re-check these keys.</p><p>The error code 3538475634 is a regular decimal number. Its hexadecimal form is d2e8da72, matching the old help link. These local failures happened while Tableau was loading the XML (the underlying file format of Tableau workbooks) document structure, but the code alone does not tell us which specific node is missing. Also, LOADED, FAIL, and UNKNOWN are simply outcomes reported by our verification script, not three native log event names from Tableau.</p><p>Third, <strong>we have to distinguish between action settings saved in the workbook file and actual clicks made by a real person</strong>. Take Hans Rosling’s classic bubble scatter plot as an example (it shows how income per person and life expectancy change over time for each country). Here, our verification script defines three specific acceptance checks:</p><ul><li>rosling-country-facts: Checks income, life expectancy, population size, and region color encoding for the country bubbles;</li><li>rosling-log-income-axis: Checks whether the income axis is set to a logarithmic scale;</li><li>rosling-region-highlight: Checks whether the highlight action is properly written into the workbook file.</li></ul><p>The following excerpt comes from the real Hans Rosling case.yaml. The first criterion specifies how country marks show income, life expectancy, population, and region. The second requires a logarithmic income axis.</p><pre>acceptance:<br>- id: rosling-country-facts<br>  description: For the selected year each mapped country is one mark positioned by<br>    its income and life expectancy, sized by population and coloured by region, with<br>    null-region countries excluded.<br>  mode: automated<br>- id: rosling-log-income-axis<br>  description: The income axis carries a logarithmic scale so the income spread is<br>    readable rather than crushed into the left edge.<br>  mode: automated</pre><p>Each criterion has an id. Setting mode: automated hands it off to an automated check. But what actually gets tested depends on what the verification script inspects. The label alone does not prove that all user interactions were tested.</p><p>I want to stress that although rosling-region-highlight is marked for automated verification in the script, it only checks whether the XML tags for the highlight action on that field are defined correctly. It does not prove that a real user clicked on a continent on the screen with a mouse.</p><p>Fourth, <strong>exporting screenshots from Tableau Cloud does not run any interactive behaviors</strong>. When we publish the workbook to Tableau Cloud and export images and CSVs with capture_case_cloud.py, the parameter browser_interaction_executed=False clearly records that no simulated clicks or mouse hovers took place. We capture Cloud screenshots to save a visual snapshot of the final output for comparing different models. Rebuilding a workbook can change internal UUIDs or zip archive bytes. That is why we finish all checks that might rebuild files first, lock the workbook in place, and only then collect Cloud snapshots to make sure everything matches the final file.</p><p>Our agents can run these scripts, but Tableau Desktop still needs a licensed local Windows environment — GitHub CI cannot replace this step. Any interactions not covered by automated tests still need manual operational proof.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*qAGwLjl94TPmRRT1.png" /></figure><p><em>Figure 4–2: Layered validation system and decision flow</em></p><h3>5. When Checks Revealed Tool Limitations, I Had AI Circle Back to Develop cwtwb</h3><p>As we worked through more test cases, we also ran into needs that our existing interfaces did not cover.</p><p>Earlier during the Donut Calendar challenge, I noticed that the AI wrote a lot of low-level XML code. To adjust cell padding and gridline styling, the AI repeatedly called etree.SubElement(...) to create internal tags by hand.</p><p>If every challenge had to deal with that same XML by hand, reusing code later would be very difficult. We needed to tuck those low-level XML operations inside cwtwb. That way, the build scripts for each case only have to call clean, easy-to-understand functions.</p><p>So I asked to expand cwtwb&#39;s public functions. Commit 5b1f53a in the case repository records our move to configure_worksheet_style. The case script only needs to state what styles it wants; the library handles all the nested XML tags and attribute settings behind the scenes.</p><p>In that conversation, I asked (translated from Chinese):</p><blockquote><em>I see a lot of etree.SubElement. Is that outside the cwtwb approach, and therefore not reusable?</em></blockquote><p>WoW commit 5b1f53a shows the move to configure_worksheet_style. This snippet from the case code shows the styling we wanted, omitting the other arguments:</p><pre>editor.configure_worksheet_style(<br>    &quot;Base&quot;,<br>    background_color=&quot;#00000000&quot;,<br>    show_column_totals=True,<br>    hide_col_field_labels=True,<br>    hide_row_field_labels=True,<br>    # Remaining style arguments omitted<br>)</pre><p>This code sets the worksheet background, column totals, and field labels. The SDK then generates the matching internal XML nodes. You can find implementation and test details in the technical appendix.</p><p>To keep changes in the underlying library from breaking features that already worked, we gradually agreed on this SDK development and regression testing workflow. We followed this convention for later runs; for earlier edits, you should still check the original records to see what steps were actually taken:</p><ol><li><strong>Save baseline</strong>: Record the state and test results of the current released version;</li><li><strong>Build minimal test cases</strong>: Write minimal reproduction snippets (fixtures), and do not import the author’s large files or private data directly;</li><li><strong>Add features and unit tests</strong>: Finish the code changes in cwtwb and write focused unit tests;</li><li><strong>Verify local changes</strong>: Use --sdk-src to point build and check tools at the local cwtwb source path we are editing. The script checks which SDK path is loaded and stops with an error if they don&#39;t match, preventing us from accidentally running an older globally installed version;</li><li><strong>Run Desktop regression tests</strong>: Run scripts/desktop/verify_corpus.py to test a 50-case baseline set in Tableau Desktop, making sure existing cases don&#39;t break;</li><li><strong>Merge code and pin version</strong>: After opening and merging the pull request in cwtwb, lock the exact merged commit hash in the case repository;</li><li><strong>Lock workbook and capture in Cloud</strong>: Rebuild the case, run independent verification, save the final files, and only then run Cloud capture.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9jvtm0DeRuF9xJ6V.png" /></figure><p><em>Figure 5–1: SDK development loop and regression workflow</em></p><p>We started doing regression checks because of painful lessons. During an audit on 2026–10–06, we ran into XML tag-ordering issues. That led to PR #7 in cwtwb, which introduced standard tag ordering whenever a file is saved. However, one fix mistyped the tag group as groups, which broke 11 workbooks that had worked fine before. We added regression tests right after fixing that typo. It was a good reminder: after solving the challenge in front of you, you always have to check that you haven&#39;t broken your past work.</p><p>Another clear example was an Excel-style grouped bar chart from the WoW 2020 W23 challenge. The chart needed 48 bars across 12 months and four years. At first, our baseline implementation rejected mark-alignment-left in its mark sizing rules. On top of that, when setting up colors for YEAR(date), the baseline logic accidentally put quotes around integer years, treating them as strings. Because of those quotes, Tableau Cloud ignored our custom color palette and fell back to default colors.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*UqNDN1JXh3JaXnXv.png" /></figure><p><em>Figure 5–2: Author’s original grouped bar chart (WoW 2020 W23)</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Oym_0Fgd0py0k-7H.png" /></figure><p><em>Figure 5–3: SDK replica grouped bar chart (minor differences: slightly larger legend dots, darker left Y-axis spine, slightly modified margin insets, none of which obscure values)</em></p><p>Once our targeted fixes landed in the SDK, the test records showed the case went from blocked to pass. We ran an independent check against the raw data, verifying all 9,994 transactions and all 48 monthly totals down to the exact sum of 2,297,200.8603. When checking against the CSV exported from Tableau Cloud, we verified values against the Tooltip:Sales field (which rounds to whole units), avoiding the rough rounding of the K-formatted axis labels. The visual check recorded acceptable minor differences rather than an exact pixel match (acceptable_delta based on our audit records). Note that this review only covers high-resolution snapshots of the default dashboard; it does not claim anyone hovered or clicked inside a browser.</p><h3>6. As Challenges Multiplied, a Single Agent Was No Longer Enough</h3><p>Once the path to build and verify individual challenges became clear, I started trying to tackle challenges in batches. Before long, though, using just a single agent began showing its limits.</p><p>Building Tableau reports involves far more than writing Python scripts. You have to read data source metadata, compare numbers against reference targets, parse Desktop logs, and fix styling errors. If you stuff multiple challenges and lengthy logs into a single conversation, the AI has to juggle an ever-growing context window. Our project records show times where long runs crashed when the context got bloated, and we had to piece things back together from logs. Breaking tasks apart also keeps the files and edits for each case much cleaner.</p><p>For example, Olympic Schedule, Streaking, and Needle in Haystack each had their own data files, build scripts, and acceptance criteria. They could proceed on their own and come back for a combined review. If one case got stuck, it didn’t hold up the rest.</p><p>To solve this, I brought in Paseo to manage separate AI sessions and workspaces.</p><p>You can think of a “subagent” as a helper AI that the primary agent starts up and assigns tasks to. In this batch of challenges, each helper ran in its own session and workspace. The primary agent kept the big picture in view, assigned challenges, and scheduled hardware resources, while subagents focused on their specific challenge inside their own working directories.</p><p>Our documentation for long-running tasks also listed several optional roles. These show how we split up the work, though not every batch needed every role:</p><ul><li><strong>Case builder agent</strong>: Analyzes assigned challenges, writes build scripts, and generates preliminary output files;</li><li><strong>Review and verification agent</strong>: Runs image and data comparisons, checking visual elements and numeric accuracy;</li><li><strong>Troubleshooting agent</strong>: When Tableau crashes reading unexpected XML, investigates logs to diagnose the cause and plan a fix;</li><li><strong>Automated checks agent</strong>: Enforces static code checks, validates paths, and runs unit tests.</li></ul><p>Looking at our actual project records, we had case subagents building solutions and separate models reviewing them independently. Having a different model do the review helps reduce blind spots from following the original builder’s train of thought, though it still cannot guarantee that a review won’t miss anything.</p><h3>7. How I Had the Primary Agent Lead Subagents to Advance a Batch of Challenges</h3><p>When we ran an actual batch of 10 challenges, coordinating everything was much more complex than I imagined. Teaming up multiple agents isn’t as simple as handing off tasks and calling it a day. We had to keep their working folders strictly separate, make sure they took turns using shared resources one at a time so they wouldn’t collide, recover cleanly whenever something got interrupted, and have different models inspect the final output independently.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/583/0*kbAcYWNGOyNqrH8r.png" /></figure><p><em>Historical task screenshot showing 8 entries and branches; it illustrates organizational structure, not standalone proof of concurrency count or acceptance outcomes</em></p><p>First, we had to <strong>keep each workspace separate and set clear boundaries for what to deliver</strong>. To keep subagents from overwriting each other’s files in the same repository, the primary agent created dedicated branches in separate Git worktrees (folders that let you check out multiple branches at once) for each helper. When handing out tasks, the primary agent laid down clear rules:</p><ul><li>Subagents can only edit files inside their assigned case folders;</li><li>The SDK (our Python toolkit for workbooks) source path must stay locked to a specific local commit, with no direct changes to the shared environment;</li><li>Shared problem descriptions and reference materials are read-only, while each case keeps its own input data;</li><li>Subagents must independently deliver build_replication.py, verify_replication.py, and updated progress logs.</li></ul><p>Here is an excerpt from a real coordinator message setting boundaries for the Olympic Schedule task (translated from Chinese):</p><blockquote><em>The user requested ten more WoW cases; you are responsible only for the first one. An independent branch and worktree have been created for you.</em></blockquote><p>I omitted the challenge link here for readability. The full assignment also spelled out the SDK, the independent build and verification scripts, the progress file, the proof files to turn in, and a rule against editing other cases or the SDK. Updating shared tools therefore required separate coordination.</p><p>We sent the first batch of work to three independent cases: Olympic Schedule, Streaking, and Needle in Haystack. As the work moved forward, the primary agent also had to coordinate shared resources.</p><p>First came <strong>Tableau Desktop client verification</strong>. Several subagents had to share a single licensed Windows machine, and our verification tools had to manage Tableau processes and log files. Running multiple instances at the same time could cause them to interfere with each other. In practice, the coordination messages set a clear rule: subagents finish their build, independent checks, and static checks first. Then, the primary coordinator runs Desktop and regression checks one at a time.</p><p>This way, subagents could keep building and report their file paths once ready. The primary coordinator then scheduled the shared Desktop checks and made sure the results were recorded. We adjusted task scopes through real coordination messages, rather than relying on Paseo to detect all dependencies and queue things automatically for me.</p><p>The second clash happened with the <strong>Cloud capture service</strong>. When rendering views remotely in headless mode and exporting CSVs, several subagents called Cloud endpoints at the same time. This knocked out each other’s sessions and triggered HTTP 401 errors. The primary agent stepped in again, telling workers to pause concurrent captures and letting the coordinator run them one by one. What we coordinated here were concrete resources and the order of execution — we didn’t set up a whole new account permissions system.</p><p>As the work ran, the coordinator updated the instructions (translated excerpts):</p><blockquote><em>To avoid concurrent Desktop use, finish the build, verifier and static gates first. Leave Desktop and corpus checks to the main coordinator to execute serially. Do not mark a case verified while its Desktop gate is missing; the main coordinator will complete it.</em></blockquote><p>These messages changed what the workers focused on right away and shifted the acceptance conditions. Later progress logs also handed Cloud captures over to the coordinator after workers running at the same time kept knocking out each other’s sessions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KTeXiUKyUpG6xmKd.png" /></figure><p><em>Schematic diagram organized from real dispatch, coordination, and review records, not a runtime interface screenshot</em></p><p>This batch also hit HTTP 429 rate limits from the model provider. Later resumption logs show that subagents using whatever models were available at the time picked up the unfinished 9th and 10th cases. Even though the worker changed, the existing branches, files, and progress logs gave them clear places to pick up the work, so we didn’t have to rerun the entire batch from scratch. It also showed that follow-up work doesn’t always have to rely on the exact same model or environment all the way through.</p><p>In fact, an earlier progress file from batch-17 already told sessions to check the progress file first after a crash, and then run git log and git status. Here is what an older Hans Rosling record showed, split into separate lines:</p><pre>01 2021-03-18 ww11 Hans Rosling<br>replicated/workaround<br>commit f283e29; LOADED; verify_corpus LOADED=50 FAIL=0 UNKNOWN=0</pre><p>The workaround notes, commits, and verification logs gave the next worker a clear starting point. Even so, whoever picks it up still has to check the actual files — an earlier passing check doesn’t prove that new changes are valid.</p><p>Beyond building workbooks, <strong>having different models do independent reviews made a huge difference in our work</strong>. Take the Extract Runs case: the initial build agent passed all static checks, and the workbook opened cleanly in Tableau Desktop. But when an independent review agent compared it visually against the original, it pointed out that our generated dashboard was missing visible “Extract Status” marks and left out the explanatory business text about the “10-minute wait threshold.”</p><p>Acting on that review feedback, the builder added the visible status marks and the threshold text. The case then went through all the verification checks again: Tableau Desktop loaded the file successfully (LOADED), we captured Cloud views across 3 different parameter states, and our independent check passed 209,640 numerical comparisons. The review logs confirmed that the issue was fixed, while keeping the visual check at an acceptable difference (acceptable_delta).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Q3LW9Ev8afM8bCGv.png" /></figure><p><em>Schematic diagram based on coordination issues from historical records, not a live dashboard</em></p><p>Looking back at our final logs from 2026–10–24, all 10 cases in this batch ended up marked as replicated, verified, and having an acceptable visual difference (acceptable_delta). In our overall checks, 83 unit tests passed, and Desktop test results across the 50 baseline cases held steady at 50 LOADED, 0 FAIL, 0 UNKNOWN. Across the broader history of the project, out of 349 candidate articles archived as of 2026-10-09, our count of solved challenges grew from 111 to 121, cutting the remaining pool from 238 down to 228. We brought all this work together onto a local coordination branch, preserving all the acceptance evidence. The historical record also makes clear: we had not pushed or merged these changes into main at that time, and these figures come from those saved logs rather than a new test run for this article.</p><h3>8. What Remains in the End Is Capability for the Next Batch of Tasks</h3><p>Looking back after completing this batch of challenges, the biggest lesson for me isn’t just the raw score of “how many challenges we had AI get through.”</p><p>Throughout this process, we didn’t fine-tune weights for any model, nor did we train custom end-to-end models. The AI here acted like an “analyst and programmer” on the team — capable of understanding tasks, using tools, and reading error logs, but whose work still requires careful checking.</p><p>What came out of this work is still ready for future use:</p><ol><li><strong>A more capable Python SDK (</strong><strong>cwtwb)</strong>: Whenever we found a missing feature we&#39;d need again (like the Pages Shelf, percentile calculations, or special mark styling), we added clean, reusable functions to the core library, backed by unit tests;</li><li><strong>A set of repeatable verification tools</strong>: Everything from checking files against XML schemas (the underlying format of Tableau workbooks) and running independent numerical validation, to Desktop checks that read Tableau’s own logs to see if a workbook loaded cleanly;</li><li><strong>A reusable way for agents to work together</strong>: The primary agent manages shared branches and locks on shared hardware, while helper agents tackle tasks in separate worktrees, supported by progress logs saved to disk and independent reviews across different models;</li><li><strong>Detailed records of our test results</strong>: How far each challenge got, the reasons for accepted visual differences, and the exact code versions we used are all documented and traceable in version control.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KdUcHx3F79uHdoql.png" /></figure><p><em>Figure 8–1: Code generation, validation, and agent orchestration capability system</em></p><p>These accumulated codebases, test suites, and verification checks remain ready for future tasks — whether run by more capable next-generation models or expanded by human developers. That said, the execution setups, interface adapters, and results for any new cases will still need careful checking.</p><p>Because the workers were allowed to read the reference solutions for these cases, they work best as a demonstration of our tools and the step-by-step refinement process, rather than a blind benchmark test on unseen challenges.</p><h3>As I write this, I am also thinking about the next step</h3><p>In the course of this project, I gradually switched to less expensive models, including DeepSeek. For many tasks, they were also able to get the job done. This was not a rigorous model comparison, but it led me to notice that stating requirements clearly, making results independently verifiable, and having a way to keep fixing errors when things break are often just as important as which model you choose.</p><p>This workflow still has shortcomings, of course, and verification can miss issues. I still believe that as models improve, reproducing these WoW challenges will become easier and easier. And when “getting the chart built” is no longer so difficult, I find myself asking instead: what kinds of charts do we really need, and why do we need them?</p><p>WoW provides a wonderful premise: the problem is clearly defined, and reference solutions are readily available. Real-world work does not always offer that. Sometimes we start building a dashboard before we have even figured out what questions to ask. AI can help us generate charts faster, but whether a question is worth analyzing, whether the numbers support the conclusions, and whether the result actually helps the user still require careful judgment.</p><p>So, in the process of repeatedly generating .twb and .twbx files, I also began to wonder: is what people truly need necessarily a fixed dashboard? Perhaps it is an analysis that allows for continuous follow-up questions, a visual that evolves with the problem, or other forms we have not yet fully thought through. I do not have a definitive answer, but I want to keep experimenting.</p><p>This has also changed how I view what I have done here. These methods may well be a transitional approach, but a temporary approach does not make the effort wasted. In getting AI to complete these challenges, I learned to write requirements clearly, to separate “it looks done” from “there is verifiable proof it is done,” and to enable different models to pick up existing work and carry it forward. These are experiences I want to bring into my next exploration.</p><p>I am sharing this code and process in the hope that it can serve as a reference for those who still have Tableau needs, and to give others an opportunity to inspect and improve upon it. Going forward, I may shift my focus toward other forms of data analysis.</p><p><strong>I do not yet know what the next step will look like, but I hope to always remember: once the chart is built, we must still return to the original question and see what it actually helped people understand.</strong></p><h3>Related Resources and Documentation</h3><ul><li>Core code repository: <a href="https://github.com/aidatacooper/cwtwb">cwtwb (Tableau Workbook SDK)</a></li><li>Challenge solutions repository: <a href="https://github.com/aidatacooper/wow-tableau-problem-solving">wow-tableau-problem-solving</a></li><li>Reference walkthroughs: <a href="https://donnacoles.home.blog/">Donna Coles — Workout Wednesday Walkthroughs</a></li></ul><p><em>This article uses historical build and verification records. Tableau and Cloud were not rerun for this write-up. Load checks, data checks and image comparisons have different scopes; they do not establish that every mouse interaction was tested.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2084c9b2cfdf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Reuse the Tableau layout, then rebuild the analysis: a Datacooper workflow]]></title>
            <link>https://medium.com/@imgwho/reuse-the-tableau-layout-then-rebuild-the-analysis-a-datacooper-workflow-acde661138b2?source=rss-818a0f4fa3b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/acde661138b2</guid>
            <dc:creator><![CDATA[Datacooper]]></dc:creator>
            <pubDate>Sun, 11 Oct 2026 01:09:54 GMT</pubDate>
            <atom:updated>2026-10-11T01:27:18.794Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vcjy-8XTAI4fSKAc.png" /></figure><p>A dashboard’s arrangement can be worth keeping even when its data and business question change. Rebuilding nested containers, spacing and text from scratch adds work before you have begun the new analysis.</p><p>Datacooper’s Tableau Layout Extractor is designed for that narrower task: take a workbook and produce a reusable structural starting point. The image above is a real screenshot of the current tool page, captured on October 11, 2026. It shows the input, output and limits; it is not a screenshot of a completed extraction or a validated Tableau rendering.</p><h3>What goes in and what comes out</h3><p>The current form accepts a TWB or TWBX workbook. You can optionally specify dashboard names and choose filenames for the layout JSON and layout-only TWB output.</p><p>The intended output contains containers, blank objects and text objects. Charts, data sources and worksheet content are outside that layout-only output. This distinction is useful when you want to keep the arrangement while replacing the analysis.</p><p>For example, suppose a team likes the hierarchy of an existing executive dashboard: a title, a KPI row and two detail panels. A layout skeleton gives the next project a place to start. The new project still needs its own data connections, worksheet definitions, calculations and interactions.</p><h3>Keep structure separate from meaning</h3><p>A layout JSON file makes the arrangement inspectable. A layout-only workbook gives a Tableau developer an artifact to review and extend. Neither establishes that the new dashboard answers the right question.</p><p>Before treating the output as a reusable template, review it in Tableau Desktop:</p><ul><li>Check container nesting, dimensions, spacing and retained text.</li><li>Replace text that belongs to the old business context.</li><li>Bind new worksheets to the appropriate data and metric definitions.</li><li>Check filters, actions and relevant dashboard states after adding the analysis.</li></ul><p>These are recommended checks, not a claim that I ran a new extraction or completed those checks for this article. Today’s verification covers the live tool page and its form implementation. The frontend sends the tableau_file_to_layout action with objects_only restoration mode to the existing server-side executor.</p><h3>What the historical post does not establish today</h3><p>My original post described this layout-reuse direction and mentioned tiled layouts. I am not extending that historical note into a current floating-layout compatibility promise. Review the particular workbook you intend to reuse.</p><p>I am also not repeating the old blanket claim that no uploaded data is stored. The current page identifies a server-side executor. Submit only files you are authorized to process and establish suitable handling requirements before using sensitive workbooks.</p><p>The open-source <a href="https://github.com/aidatacooper/cwtwb">cwtwb repository</a> is the broader workbook engineering context. Datacooper’s planned paid MCP is a separate product direction: help carry a BI task through clearer inputs, construction and review. Access is not open yet; this article does not announce a paid service launch.</p><p>Try the focused <a href="https://datacooper.com/en/tools/tableau-layout-extractor">Tableau Layout Extractor</a>, and review its output before incorporating it into a new dashboard.</p><h3>Sources and project links</h3><ul><li><a href="https://www.linkedin.com/feed/update/urn:li:activity:7455823450931351552/">Original historical post</a> — retained as a source only.</li><li><a href="https://datacooper.com/en/tools/tableau-layout-extractor">Current tool description, inputs and limits</a>.</li><li><a href="https://github.com/aidatacooper/cwtwb">cwtwb on GitHub</a>.</li><li><a href="https://github.com/aidatacooper/wow-tableau-problem-solving">Public workbook replication cases</a>.</li><li><a href="https://datacooper.com/en">Datacooper</a> and <a href="https://datacooper.com/en/mcp#waitlist">planned MCP early access</a>.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=acde661138b2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Change one Tableau KPI without changing the whole workbook: a cwtwb example]]></title>
            <link>https://medium.com/@imgwho/change-one-tableau-kpi-without-changing-the-whole-workbook-a-cwtwb-example-5cb0fd513cea?source=rss-818a0f4fa3b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/5cb0fd513cea</guid>
            <dc:creator><![CDATA[Datacooper]]></dc:creator>
            <pubDate>Sat, 10 Oct 2026 01:27:56 GMT</pubDate>
            <atom:updated>2026-10-10T01:32:36.010Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PA_trB29GyYTP7sl.png" /></figure><p>You need a Profit version of a Sales KPI. The original Sales view must keep working. That is a small request with a surprisingly important boundary: change the new worksheet’s calculation chain, rather than replace a shared measure throughout the workbook.</p><p>This was the problem behind my earlier Datacooper post about local KPI replacement. Here is a concrete example from cwtwb, the open-source Python workbook authoring SDK.</p><p>Start with an existing workbook</p><p>The checked-in example opens 5 KPI Design Ideas (2).twb, copies the worksheet 1. KPI to 1. KPI Profit, and applies the mapping Sales -&gt; Profit to the copy. It then makes the copied worksheet visible and saves a separate output workbook.</p><p>editor = TWBEditor.open_existing(SOURCE)</p><p>if TARGET_WORKSHEET not in editor.list_worksheets():</p><p>editor.clone_worksheet(“1. KPI”, TARGET_WORKSHEET)</p><p>editor.apply_worksheet_refactor(TARGET_WORKSHEET, {“Sales”: “Profit”})</p><p>editor.set_worksheet_hidden(TARGET_WORKSHEET, hidden=False)</p><p>editor.save(OUTPUT)</p><p>This is an excerpt from the real example script, not a complete standalone program. The image reproduces the same source code; it is not a Tableau rendering or a test-results screenshot.</p><p>Why copying the view is only the first step</p><p>A KPI can depend on calculated fields, not just the measure visible on a shelf. The local refactor needs to account for that calculation chain. The example documentation also describes normalization of generic Calculation_* identities to Profit-based names, so the copied view does not retain misleading Sales labels.</p><p>For an agent, the useful sequence is to inspect the source worksheet, clone it, preview the refactor, apply the bounded change and review the saved artifact. cwtwb exposes preview_worksheet_refactor alongside the apply operation, so the proposed changes can be inspected before committing them.</p><p>What the repository checks, and what you still need to check</p><p>The repository’s worksheet-refactor test checks that the original worksheet retains Sales formulas while the clone contains Profit formulas. It also checks renamed calculation identities and the saved workbook’s worksheet XML. These are assertions in the test source; this article does not claim a new test run or a new Tableau render.</p><p>That scope matters. XML checks alone do not establish correct business definitions, correct rendered labels, or every dashboard interaction. Before using the output in production, open it in Tableau, review the KPI values and labels, exercise relevant filters and dates, and compare the unaffected views with the original workbook. Sales and Profit also have different business meanings: preserving a formula’s structure does not establish that its interpretation remains appropriate.</p><p>This example is about a single worksheet. It is not a claim that every multi-sheet KPI module or arbitrary workbook can be migrated without review, and it makes no timing guarantee.</p><p>At Datacooper, I am building toward workflows that make those boundaries visible: clear inputs, inspectable changes, editable workbooks and evidence of the result. A paid MCP remains planned; the public SDK example is available now.</p><p>Sources:</p><p>- Original Datacooper post: <a href="https://www.linkedin.com/feed/update/urn:li:activity:7450852658707345408/">https://www.linkedin.com/feed/update/urn:li:activity:7450852658707345408/</a></p><p>- Actual example script: <a href="https://github.com/aidatacooper/cwtwb/blob/876bd222011237edd84b1e2649a4fe213ff263db/examples/worksheet_refactor_kpi_profit/worksheet_refactor.py">https://github.com/aidatacooper/cwtwb/blob/876bd222011237edd84b1e2649a4fe213ff263db/examples/worksheet_refactor_kpi_profit/worksheet_refactor.py</a></p><p>- Worksheet-refactor test source: <a href="https://github.com/aidatacooper/cwtwb/blob/876bd222011237edd84b1e2649a4fe213ff263db/tests/test_worksheet_refactor.py">https://github.com/aidatacooper/cwtwb/blob/876bd222011237edd84b1e2649a4fe213ff263db/tests/test_worksheet_refactor.py</a></p><p>Explore cwtwb on GitHub: <a href="https://github.com/aidatacooper/cwtwb">https://github.com/aidatacooper/cwtwb</a> and Datacooper: <a href="https://datacooper.com/en.">https://datacooper.com/en.</a></p><p><em>Originally published at </em><a href="https://datacooper.substack.com/p/change-one-tableau-kpi-without-changing"><em>https://datacooper.substack.com</em></a><em> on October 10, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5cb0fd513cea" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Screenshot to layout JSON to TWB: a cwtwb dashboard skeleton experiment]]></title>
            <link>https://medium.com/@imgwho/screenshot-to-layout-json-to-twb-a-cwtwb-dashboard-skeleton-experiment-6cc79a070d5c?source=rss-818a0f4fa3b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/6cc79a070d5c</guid>
            <dc:creator><![CDATA[Datacooper]]></dc:creator>
            <pubDate>Mon, 05 Oct 2026 09:38:13 GMT</pubDate>
            <atom:updated>2026-10-05T09:38:13.316Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*BmeFKIKoFdZCiWFeYHZ3xQ.png" /></figure><p>Nested Tableau containers can consume a surprising amount of dashboard-building time. In this experiment, I asked an AI to infer a layout from a screenshot, save layout JSON and use cwtwb to generate a workbook.</p><p>The output deliberately used text placeholders. I explicitly allowed mocked calculations because this test was about layout construction.</p><p>The prompt’s important boundary</p><p>text<br>Generate the layout JSON and save it locally, then use this JSON<br>to generate the final dashboard. I don’t need you to perfectly<br>replicate the calculations; you can just mock up a few.</p><p>This is an excerpt from the original prompt, rather than a runnable SDK example.</p><p>Why the intermediate JSON helps</p><p>The workflow has three inspectable stages:</p><p>text<br>Reference screenshot -&gt; layout JSON -&gt; Tableau workbook (.twb)</p><p>A screenshot communicates arrangement. The layout description makes horizontal and vertical nesting explicit. The workbook turns that description into an artifact that can be opened and edited in Tableau.</p><p>The generated skeleton looked unfinished because its job was to expose structure, not to impersonate a verified production dashboard. The container hierarchy was the focus of the original review.</p><p>What still needs to happen</p><p>This demonstration does not establish pixel-perfect replication or calculation correctness. Real data bindings, calculations, styles and interactions need their own implementation and checks.</p><p>That distinction is central to cwtwb’s development: build from public SDK operations, then verify the artifact against a concrete case. Datacooper’s planned paid MCP should help carry that workflow further toward finished BI work, with reviewable intermediate results.</p><p>Originally shared in this LinkedIn post (<a href="https://www.linkedin.com/feed/update/urn:li:activity:7435683330072797184/">https://www.linkedin.com/feed/update/urn:li:activity:7435683330072797184/</a>).</p><p>Explore cwtwb on GitHub (<a href="https://github.com/aidatacooper/cwtwb">https://github.com/aidatacooper/cwtwb</a>), the case replication repository (<a href="https://github.com/aidatacooper/wow-tableau-problem-solving">https://github.com/aidatacooper/wow-tableau-problem-solving</a>) and Datacooper (<a href="https://datacooper.com/en">https://datacooper.com/en</a>).</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6cc79a070d5c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From raw data to a dashboard blueprint: testing a Tableau design Skill]]></title>
            <link>https://medium.com/@imgwho/from-raw-data-to-a-dashboard-blueprint-testing-a-tableau-design-skill-18cd0e37b97c?source=rss-818a0f4fa3b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/18cd0e37b97c</guid>
            <dc:creator><![CDATA[Datacooper]]></dc:creator>
            <pubDate>Mon, 05 Oct 2026 09:35:07 GMT</pubDate>
            <atom:updated>2026-10-05T09:35:07.841Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/160/1*8MlEct5K14KWRprGRnGoJQ.jpeg" /></figure><p>Before generating a workbook, an agent needs to decide what the dashboard is for. I tested Adam Mico’s open-source Tableau Dashboard Blueprint Skill with the Antigravity CLI to explore that step.</p><p>The experiment produced a technical specification and an interactive HTML prototype. It was a design test, not proof of a completed Tableau workbook.</p><p>What the Skill helped make explicit</p><p>The design identified a sales-manager audience, a short review window, KPI hierarchy and a restrained filter set. It also described the layout and the charts that would answer the intended questions.</p><p>The technical specification included container hierarchy and calculation definitions. The HTML prototype made the proposed arrangement easier to review before implementation. In the original experiment, simulated regional filtering updated the prototype KPIs.</p><p>Those are different outputs with different purposes: the specification tells a builder what to implement; the prototype lets someone inspect the proposed experience.</p><p>Where cwtwb fits</p><p>My next-step proposal in the original post was to connect the design workflow to cwtwb. That was a plan at the time, and I am preserving that distinction here.</p><p>A useful future workflow would take an agreed specification, construct a Tableau workbook through the SDK and compare the result with the intended design. It would still need to check the real data and calculations separately from the prototype.</p><p>For Datacooper, this suggests a practical product direction: help users move from a business question to an inspectable build specification and an editable artifact. The paid MCP is planned around that broader task.</p><p>Credit and references:</p><p>- Adam Mico’s Blueprint Skill (<a href="https://github.com/adammico-lab/Tableau-Dashboard-Blueprint-BETA/blob/main/SKILL.md">https://github.com/adammico-lab/Tableau-Dashboard-Blueprint-BETA/blob/main/SKILL.md</a>)<br>- The experiment’s published prototype (<a href="https://aidatacooper.github.io/20260714-tableaudesign/">https://aidatacooper.github.io/20260714-tableaudesign/</a>)</p><p>Originally shared in this LinkedIn post (<a href="https://www.linkedin.com/feed/update/urn:li:activity:7482620478189314049/">https://www.linkedin.com/feed/update/urn:li:activity:7482620478189314049/</a>).</p><p>Explore cwtwb on GitHub (<a href="https://github.com/aidatacooper/cwtwb">https://github.com/aidatacooper/cwtwb</a>), the case replication repository (<a href="https://github.com/aidatacooper/wow-tableau-problem-solving">https://github.com/aidatacooper/wow-tableau-problem-solving</a>) and Datacooper (<a href="https://datacooper.com/en">https://datacooper.com/en</a>).</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=18cd0e37b97c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What a Tableau MCP source-code experiment taught me about workbook authoring]]></title>
            <link>https://medium.com/@imgwho/what-a-tableau-mcp-source-code-experiment-taught-me-about-workbook-authoring-89645a8f3c72?source=rss-818a0f4fa3b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/89645a8f3c72</guid>
            <dc:creator><![CDATA[Datacooper]]></dc:creator>
            <pubDate>Mon, 05 Oct 2026 09:34:00 GMT</pubDate>
            <atom:updated>2026-10-05T09:34:00.879Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/160/1*3qu2Z0uFgVkd-sSdBgepbg.jpeg" /></figure><p>When I explored the official tableau-mcp source in an earlier experiment, one area caught my attention: workbook tools under src/tools/desktop/workbook/.</p><p>The screenshot and original LinkedIn post record that historical observation. This article describes the design idea I took from it; it does not assert that those tools are currently available to every developer.</p><p>Three names that made the workflow interesting</p><p>The tool names recorded in my original analysis were:</p><p>text<br>get-workbook-xml<br>batch-create-and-cache-sheets<br>apply-workbook</p><p>Read together, they suggest an authoring workflow with separate steps: inspect the existing workbook, prepare new sheets, then apply changes. That is a useful design distinction for an agent: reading, creating and committing changes are different operations.</p><p>This is my interpretation of the names and the historical source observation. It is not proof of public access to a Desktop Agent API, and I am not claiming I successfully executed that internal workflow.</p><p>Why it matters for cwtwb</p><p>There are several ways to approach AI-assisted BI. One works with an active application. Another generates a workbook artifact programmatically. cwtwb focuses on the latter through a Python SDK and MCP-facing capabilities.</p><p>Both approaches raise the same practical questions: what did the agent change, can we inspect the result, and is the calculation correct?</p><p>An official project exploring workbook authoring is relevant technical context. It is not an endorsement of Datacooper or evidence of market leadership.</p><p>My work at Datacooper is to turn that authoring direction into repeatable examples and checked artifacts. A future paid MCP should earn its value by helping users complete BI tasks, not merely by exposing more tool names.</p><p>Project context: Tableau MCP repository (<a href="https://github.com/tableau/tableau-mcp">https://github.com/tableau/tableau-mcp</a>).</p><p>Originally shared in this LinkedIn post (<a href="https://www.linkedin.com/feed/update/urn:li:activity:7472231893623746560/">https://www.linkedin.com/feed/update/urn:li:activity:7472231893623746560/</a>).</p><p>Explore cwtwb on GitHub (<a href="https://github.com/aidatacooper/cwtwb">https://github.com/aidatacooper/cwtwb</a>), the case replication repository (<a href="https://github.com/aidatacooper/wow-tableau-problem-solving">https://github.com/aidatacooper/wow-tableau-problem-solving</a>) and Datacooper (<a href="https://datacooper.com/en">https://datacooper.com/en</a>).</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=89645a8f3c72" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[An AI semi-donut experiment: who checks the visualization logic?]]></title>
            <link>https://medium.com/@imgwho/an-ai-semi-donut-experiment-who-checks-the-visualization-logic-98e874664919?source=rss-818a0f4fa3b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/98e874664919</guid>
            <dc:creator><![CDATA[Datacooper]]></dc:creator>
            <pubDate>Mon, 05 Oct 2026 09:32:54 GMT</pubDate>
            <atom:updated>2026-10-05T09:32:54.276Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*K97oOOaYz96lQ-zLrmvm1g.jpeg" /></figure><p>A semi-donut chart looks small on a dashboard. Building it can involve considerably more work than its appearance suggests.</p><p>In this early experiment, I gave an AI reference material and asked it to produce the calculation logic and visualization. The original screenshot shows the output. My role shifted toward specifying the design, reviewing it and iterating, rather than manually writing every step.</p><p>Why this experiment mattered</p><p>The hard part of an unusual chart is not simply choosing a mark type. The calculation and visual construction need to agree. A plausible-looking chart can still misrepresent the underlying value.</p><p>That makes this a useful test of AI-assisted Tableau authoring. Can an agent translate the reference into a workbook? Can a human understand and check what it produced?</p><p>Keep generation and verification separate</p><p>For this kind of chart, I would review the source values, how they map to the visible shape, the labels and any assumptions about the scale. Those are review criteria, not a claim that this historical screenshot includes a complete audit.</p><p>The original post also discussed Tableau Prep automation. Data preparation and workbook authoring are distinct stages; a good-looking final chart cannot establish that its upstream data pipeline is correct.</p><p>At Datacooper, cwtwb is the open-source workbook authoring foundation. The case replication repository provides a place to exercise capabilities against concrete examples and retain validation evidence.</p><p>The commercial opportunity I am exploring is a paid MCP that helps analysts finish actual BI work: specify the question, construct the workbook and review the output. The analyst’s judgment remains central.</p><p>Originally shared in this LinkedIn post (<a href="https://www.linkedin.com/feed/update/urn:li:activity:7432996083385155585/">https://www.linkedin.com/feed/update/urn:li:activity:7432996083385155585/</a>).</p><p>Explore cwtwb on GitHub (<a href="https://github.com/aidatacooper/cwtwb">https://github.com/aidatacooper/cwtwb</a>), the case replication repository (<a href="https://github.com/aidatacooper/wow-tableau-problem-solving">https://github.com/aidatacooper/wow-tableau-problem-solving</a>) and Datacooper (<a href="https://datacooper.com/en">https://datacooper.com/en</a>).</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=98e874664919" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building an editable Tableau dashboard with cwtwb and MCP]]></title>
            <link>https://medium.com/@imgwho/building-an-editable-tableau-dashboard-with-cwtwb-and-mcp-55f6407087d4?source=rss-818a0f4fa3b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/55f6407087d4</guid>
            <category><![CDATA[tableau]]></category>
            <dc:creator><![CDATA[Datacooper]]></dc:creator>
            <pubDate>Mon, 05 Oct 2026 09:19:23 GMT</pubDate>
            <atom:updated>2026-10-05T09:20:14.096Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*IyBiMlehxUUJC-0CQPnQhg.jpeg" /></figure><p>A dashboard generated by AI should leave you with a workbook you can keep working on. That was the question behind this early cwtwb experiment: could an agent assemble a Tableau dashboard without manually dragging sheets onto the canvas?</p><p>The screenshot shows the resulting workbook alongside the prompt. It includes sales by sub-category, sales by category, a monthly profit trend and a regional sales breakdown. The useful output is the Tableau .twb file, rather than an image of a dashboard.</p><p>How the workflow works</p><p>1. Describe the charts and dashboard you need.<br>2. The agent calls the MCP tools to configure workbook elements.<br>3. The implementation writes the workbook structure, including worksheets and layout containers.<br>4. Open the output in Tableau and review the result.</p><p>A TWB stores workbook definitions as XML. cwtwb provides a Python SDK so callers can work with higher-level operations instead of assembling that XML manually. MCP gives an agent a way to call those operations.</p><p>What this demonstration does and does not prove</p><p>This is a retrospective of an early prototype. The screenshot demonstrates workbook authoring; it does not prove every business calculation or interaction is correct. A production workflow also needs input checks, calculation validation, rendered output and tests of relevant parameter or filter states.</p><p>Today, the open-source SDK and the Workout Wednesday replication repository help make that review process concrete: a build script, locked input data, a workbook and recorded checks.</p><p>My planned paid MCP builds on that direction: help complete real BI tasks with clearer inputs, repeatable builds and evidence of the result. It remains a product plan, not a claim that every BI task is already automated.</p><p>Originally shared in this LinkedIn post (<a href="https://www.linkedin.com/feed/update/urn:li:activity:7433095198680764417/">https://www.linkedin.com/feed/update/urn:li:activity:7433095198680764417/</a>).</p><p>Explore cwtwb on GitHub (<a href="https://github.com/aidatacooper/cwtwb">https://github.com/aidatacooper/cwtwb</a>), the case replication repository (<a href="https://github.com/aidatacooper/wow-tableau-problem-solving">https://github.com/aidatacooper/wow-tableau-problem-solving</a>) and Datacooper (<a href="https://datacooper.com/en">https://datacooper.com/en</a>).</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=55f6407087d4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[开启Ubuntu系统]]></title>
            <link>https://medium.com/@imgwho/%E5%BC%80%E5%90%AFubuntu%E7%B3%BB%E7%BB%9F-7bfc9d3d1543?source=rss-818a0f4fa3b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/7bfc9d3d1543</guid>
            <dc:creator><![CDATA[Datacooper]]></dc:creator>
            <pubDate>Mon, 25 Feb 2019 03:52:24 GMT</pubDate>
            <atom:updated>2019-02-25T03:52:24.679Z</atom:updated>
            <content:encoded><![CDATA[<p># 开启Ubuntu系统</p><p>1. 设置 安全 针对开发人员 点上开发人员模式</p><p>![TIM截图20171107191640.png](http://upload-images.jianshu.io/upload_images/1941853-5f22dd2c03f78cd3.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)</p><p>2. 控制面板 启用或关闭windows功能 点上 适用于linux的windows子系统</p><p>![TIM截图20171107191809.png](http://upload-images.jianshu.io/upload_images/1941853-c9f63a77e0d24728.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)</p><p>3. 打开windows商店搜索linux。选择自己喜欢的linux系统安装，启动，设置密码。</p><p># 使用Ubuntu系统</p><p>1. 查看Ubuntu版本: 在cmd输入bash进入子系统，输入 lsb_release -a ，如果你是14.x建议你先将win10升级到最新版1709，再执行 sudo do-release-upgrade 升级ubuntu系统</p><p>![TIM截图20171107192615.png](http://upload-images.jianshu.io/upload_images/1941853-563befa03129ab43.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)</p><p>2. 更换Ubuntu镜像源: 源理解成Ubuntu安装软件需要的依赖。由于你懂的原因，原生的Ubuntu源非常慢，所以换到国内的中科大镜像源。首先，在修改source.list前，备份源文件，具体可以查linux cp(复制)命令:sudo cp /etc/apt/sources.list /etc/apt/sources.list.bak，然后sudo vim /etc/apt/sources.list将</p><p>```</p><p># 默认注释了源码镜像以提高 apt update 速度，如有需要可自行取消注释</p><p>deb <a href="https://mirrors.ustc.edu.cn/ubuntu/">https://mirrors.ustc.edu.cn/ubuntu/</a> xenial main restricted universe multiverse</p><p># deb-src <a href="https://mirrors.ustc.edu.cn/ubuntu/">https://mirrors.ustc.edu.cn/ubuntu/</a> xenial main main restricted universe multiverse</p><p>deb <a href="https://mirrors.ustc.edu.cn/ubuntu/">https://mirrors.ustc.edu.cn/ubuntu/</a> xenial-updates main restricted universe multiverse</p><p># deb-src <a href="https://mirrors.ustc.edu.cn/ubuntu/">https://mirrors.ustc.edu.cn/ubuntu/</a> xenial-updates main restricted universe multiverse</p><p>deb <a href="https://mirrors.ustc.edu.cn/ubuntu/">https://mirrors.ustc.edu.cn/ubuntu/</a> xenial-backports main restricted universe multiverse</p><p># deb-src <a href="https://mirrors.ustc.edu.cn/ubuntu/">https://mirrors.ustc.edu.cn/ubuntu/</a> xenial-backports main restricted universe multiverse</p><p>deb <a href="https://mirrors.ustc.edu.cn/ubuntu/">https://mirrors.ustc.edu.cn/ubuntu/</a> xenial-security main restricted universe multiverse</p><p># deb-src <a href="https://mirrors.ustc.edu.cn/ubuntu/">https://mirrors.ustc.edu.cn/ubuntu/</a> xenial-security main restricted universe multiverse</p><p># 预发布软件源，不建议启用</p><p># deb <a href="https://mirrors.ustc.edu.cn/ubuntu/">https://mirrors.ustc.edu.cn/ubuntu/</a> xenial-proposed main restricted universe multiverse</p><p># deb-src <a href="https://mirrors.ustc.edu.cn/ubuntu/">https://mirrors.ustc.edu.cn/ubuntu/</a> xenial-proposed main restricted universe multiverse</p><p>```</p><p>复制粘贴即可，最后sudo apt-get update完成换源操作</p><p>3. 安装nodejs：</p><p>这个系统是完全独立的系统，所以以前windows上安装的nodejs啊git啊这些，现在在Ubuntu上是要重新安装的，具体的安装软件就不一一详解了，google一下就知道，这里说说最麻烦的nodejs首先curl命令下载nodejs源码:</p><p>curl -sL `https://deb.nodesource.com/setup_9.x` | sudo -E bash -</p><p>然后Ubuntu包管理安装nodejs(这个时候会读取刚才下载的源码千万不要直接先进行这一步，否则Ubuntu会在它的源上下载非常非常老的nodejs版本，大概是4.x):</p><p>sudo apt-get install -y nodejs</p><p>再使用npm的n模块管理npm版本：</p><p>清理缓存 sudo npm cache clean -f</p><p>全局安装n模块 sudo npm install -g n</p><p>安装最近的一个稳定版 sudo n stable</p><p>安装最近的一个正式版 sudo n latest</p><p>然后安装nrm。nrm ls查看可用的npm源，npm use相应的npm源。</p><p>4. vscode设置：ctrl shift p 选择默认bash ![TIM截图20171107195209.png](http://upload-images.jianshu.io/upload_images/1941853-91a36926dade625d.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)选第三个![TIM截图20171107195248.png](http://upload-images.jianshu.io/upload_images/1941853-ef3bd36eacf08173.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) 然后就可以在windows愉快的开发撸~~ 再也不用担心windows下类似npm路径&amp;*一堆奇葩的错误</p><p>5. 这个系统到底在我电脑的哪个目录？</p><p>C:\Users\\%UserProfile%\AppData\Local\lxss</p><p>%UserProfile%是当前用户名</p><p>6. 在这个系统下如何进入我windows下的目录呢？</p><p>cd /mnt/然后ls你就发现你可爱的windows的cdefghi盘了</p><p>7. 能右键打开这个系统吗？</p><p>你只需要下载conemu即可 [conemu配置参考](http://blog.csdn.net/M1mory/article/details/72591289)</p><p>当然了，也可以直接下载我配置好的[拿去用 conemu](https://pan.baidu.com/s/1dFCQ8wh)![TIM截图20171107200949.png](http://upload-images.jianshu.io/upload_images/1941853-43b50df957bfc217.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)</p><p>## 现在可以直接在win10下写代码而不用担心奇葩环境问题了~~</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7bfc9d3d1543" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>