Skip to content
Skills Library
Data & analytics · Conversion & formats

tableau-data

/tableau-data

Acquires the data for a tableau-dashboard-plugin project and writes the DATA-MODEL.md handoff artifact. CSV mode (the default, zero-credential path) profiles the analyst's data/*.csv into documented field names + types and validates that headers match exactly; the scaffold/sample-data/ demo CSVs are the fallback. The published-ds route (datasources.json + .env) samples published sources through the VizQL Data Service into data/*.csv. Use when the user wants to acquire or model dashboard data, build DATA-MODEL.md, or when tableau-route reports data is next. Step 3 of 8 in the workflow.

Licence
MIT
Last repository change
17.09.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
6
Scripts
5
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 17.09.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 5 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: scripts/constants.py, scripts/data.py, scripts/datamodel.py, scripts/state.py, scripts/vds.py

What it does and when to use it

Acquires the data for a tableau-dashboard-plugin project and writes the DATA-MODEL.md handoff artifact. CSV mode (the default, zero-credential path) profiles the analyst's data/*.csv into documented field names + types and validates that headers match exactly; the scaffold/sample-data/ demo CSVs are the fallback. The published-ds route (datasources.json + .env) samples published sources through the VizQL Data Service into data/*.csv. Use when the user wants to acquire or model dashboard data, build DATA-MODEL.md, or when tableau-route reports data is next. Step 3 of 8 in the workflow.

Original author description

Acquires the data for a tableau-dashboard-plugin project and writes the DATA-MODEL.md handoff artifact. CSV mode (the default, zero-credential path) profiles the analyst's data/*.csv into documented field names + types and validates that headers match exactly; the scaffold/sample-data/ demo CSVs are the fallback. The published-ds route (datasources.json + .env) samples published sources through the VizQL Data Service into data/*.csv. Use when the user wants to acquire or model dashboard data, build DATA-MODEL.md, or when tableau-route reports data is next. Step 3 of 8 in the workflow.

How it works

  1. The two acquisition routes (and no third)
  2. How to run
  3. The DATA-MODEL.md schema
  4. Notes
Original SKILL.md headings · 156 lines, 1,249 words
SKILL.md preview
---
name: tableau-data
description: Acquires the data for a tableau-dashboard-plugin project and writes the DATA-MODEL.md handoff artifact. CSV mode (the default, zero-credential path) profiles the analyst's data/*.csv into documented field names + types and validates that headers match exactly; the scaffold/sample-data/ demo CSVs are the fallback. The published-ds route (datasources.json + .env) samples published sources through the VizQL Data Service into data/*.csv. Use when the user wants to acquire or model dashboard data, build DATA-MODEL.md, or when tableau-route reports data is next. Step 3 of 8 in the workflow.
disable-model-invocation: true
allowed-tools: Read, Write, Edit, AskUserQuestion, Bash(python *), Bash(python3 *)
---

# tableau-data

Step 3 of 8, and **non-skippable**. It turns the analyst's data into `DATA-MODEL.md`
— the documented field names and types that `tableau-mock` and `tableau-build`
build against. The CSVs under `data/` are the single source of truth for those field
names, so this step also **validates that the documented names match the real CSV
headers exactly** before approving.

| | |
|---|---|
| **Reads** | The data: production `data/*.csv` (preferred) **or** the `scaffold/sample-data/*.csv` demo fallback. For the published-ds route, the inputs `datasources.json` + `.env` (the latter discovered by walking up — nearest wins). None is a *required read* — `data` has no producer-gated inputs (CONTRACT.md §1). |
| **Writes** | `DATA-MODEL.md` at the project root (latest approved truth; overwritten in place). The CSVs themselves are analyst-provided in `data/` (or the demo `scaffold/sample-data/`). |
| **STATE.md update** | Sets `data` = `approved`; flips every downstream `approved` step to `stale` on a re-run (CONTRACT.md §4.2). |
| **Entry gate** | Refuses to run until `init` is `approved` in `STATE.md` (CONTRACT.md §4.1). |
| **Next step** | `tableau-brand` (or `tableau-plan`, or `tableau-route` to confirm). |

## The two acquisition routes (and no third)

There are exactly **two** ways to get the mimicking CSVs (CONTRACT.md §3.2). There is
**no** synthesized/random-data path — when no real data exists, the floor is the
clearly-labelled `scaffold/sample-data/` demo, never invented rows.

- **Route 1 — `data_mode: csv` (default, zero-credential).** The analyst drops CSV
  file(s) in `data/`. **Each CSV is one data source.** `profile` → enrich → `commit`.
- **Route 2 — `data_mode: published-ds` (VizQL Data Service).** The analyst lists
  published sources in `datasources.json` (one entry each: `ds_name` + `project_name`)
  and supplies a Tableau connection in `.env`. `pull` signs in with the Personal Access
  Token and samples each source through the VDS — `read-metadata` (authoritative field
  names/types/descriptions) then `query-datasource` (a capped row sample) — writing one
  `data/<slug>.csv` per source plus `DATA-MODEL.md`. Then enrich → `commit`, exactly as
  Route 1. **Fires only when `data/` has no production CSVs** (real CSVs always win).

The mechanical guarantees — the entry gate, CSV profiling/type inference, the VDS pull,
the header↔model validation, and the STATE.md transition — live in `data.py` (with the
VDS client in `vds.py`), this skill's executable mirror of the contract. Your job is the
judgment part: confirming which route applies and enriching each field's **Description**
in `DATA-MODEL.md`. Run the script at the points below; do not hand-edit `STATE.md`.

## How to run

1. **Precheck.** From the project directory, run:

   ```bash
   python "${CLAUDE_PLUGIN_ROOT}/skills/tableau-data/scripts/data.py" precheck "<project-dir>"
   ```

   (Use `python3` if `python` is unavailable.) If it prints `[BLOCKED]`, relay the
   reason and **stop** — the analyst must run `tableau-init` first. Otherwise note its
   signals: the csv source (production `data/`, demo `scaffold/sample-data/`, or
   `none`), whether Route 2 inputs are present, whether a `DATA-MODEL.md` already
   exists, and the current `data` status (a re-run).

2. **Branch on the situation** precheck reported:
   - **CSV available** (`data/` or the demo) → go to step 3 (profile).
   - **Route 2** (`datasources.json` + `.env`, no production CSVs) → go to step 3a (pull).
     If `datasources.json` is present but `.env` is missing, tell the analyst to copy
     `scaffold/.env.example` to `.env` and fill in their Tableau connection first.
   - **Nothing** → tell the analyst to either drop CSV(s) in `data/`, or add
     `datasources.json` + `.env` for the published-ds route. To just demo the
     workflow they can re-run `tableau-init` to lay down the `scaffold/sample-data/`
     examples. **Stop.**

3a. **Pull (published-ds route only).** Sample the listed published sources via VDS:

   ```bash
   python "${CLAUDE_PLUGIN_ROOT}/skills/tableau-data/scripts/data.py" pull "<project-dir>"
   ```

   This signs in with the PAT, and for each source pulls metadata + a capped row sample,
   writing one `data/<slug>.csv` (slug = lowercased `ds_name`, e.g. `Regional Sales` →
   `regional_sales.csv`) and a schema-complete `DATA-MODEL.md` (tier
   `published-ds (VDS query)`, types/descriptions taken from VDS metadata). It also sets
   `data_mode: published-ds` in `STATE.md`. The row cap is `--row-limit` (default `100`,
   **silent up to `1000`**); a value **above `1000` is refused** until you confirm the
   larger sample with the analyst and re-run with `--confirm-large`. `pull` is
   **non-destructive** (refuses if `DATA-MODEL.md` exists; re-run with `--force` to
   re-sample). If it prints `[REFUSED]`, relay the actionable reason and **stop** — no
   artifact is written on failure (sign-in/connection error, the source's **API Access**
   capability is off, the named source is not a *published* source — it may be
   **embedded**, in which case export it to CSV and use Route 1 — or the query returned
   zero rows). On success, go to step 4 (enrich) — there is no separate `profile` step
   for this route.

3. **Profile (csv route only).** Generate the field tables from the resolved CSVs:

   ```bash
   python "${CLAUDE_PLUGIN_ROOT}/skills/tableau-data/scripts/data.py" profile "<project-dir>"
   ```

   This infers a type per column and writes a schema-complete `DATA-MODEL.md`. It is
   **non-destructive**: if `DATA-MODEL.md` already exists it refuses (so prior
   descriptions aren't clobbered) — `Edit` it in place to refine, or re-run with
   `--force` to regenerate from the CSVs (e.g. after the data changed). If precheck
   said the source was the **demo** fallback, **tell the analyst** you're profiling
   demo data, not their real source.

4. **Enrich `DATA-MODEL.md`.** `Edit` each data source's field table to fill the
   **Description** column (and refine **Role** — `Dimension`/`Measure` — where the
   numeric heuristic guessed wrong). **Do not rename fields** — the documented field
   names must stay identical to the CSV headers (commit enforces this). Present the
   `DATA-MODEL.md` for approval.

5. **Commit** — only after the analyst approves:

   ```bash
   python "${CLAUDE_PLUGIN_ROOT}/skills/tableau-data/scripts/data.py" commit "<project-dir>"
   ```

   The script validates every documented field name against the real CSV header
   (exact match, case included). If it prints `[REFUSED]` naming missing/extra
   fields, fix the drift in `DATA-MODEL.md` (or the CSV) and re-run. On success it
   records `data` = `approved` and reports any downstream steps it marked `stale`.
   Relay the summary and tell the analyst to open a fresh conversation and run the
   next step (`tableau-route` to confirm).

## The DATA-MODEL.md schema

`profile` (csv route) or `pull` (published-ds route) generates this; the model enriches
the Description (and refines Role) cells. For the published-ds route, Type and any
Description come pre-filled from authoritative VDS metadata.

```markdown
## Acquisition
- tier: csv (provided in data/)        # or: csv (demo - scaffold/sample-data/), or: published-ds (VDS query)

## Data source: `sales_orders.csv`
- rows profiled: 40

| Field      | Type    | Role      | Sample values        | Description    |
|------------|---------|-----------|----------------------|----------------|
| order_id   | string  | Dimension | ORD-001, ORD-002     | <model fills>  |
| revenue    | real    | Measure   | 971.89, 1499.95      | <model fills>  |
```

- **One `## Data source:` section per CSV** (CONTRACT.md §3.2 — "csv = datasource").
- **Type** is one of `string`, `integer`, `real`, `date`, `datetime`, `boolean`.
- **Acquisition tier** is recorded so downstream steps know whether this is the
  analyst's real data or the demo fallback.
- `commit` re-parses the **Field** column and checks it against the CSV headers, so
  keep the table structure intact when enriching.

## Notes

- **Non-skippable.** Unlike `intake`/`brand`, `data` cannot be skipped — the pipeline
  has no field names to build against without it. `commit` only ever sets `approved`.
- **Latest-truth file.** `DATA-MODEL.md` lives at the project root and is overwritten
  in place; re-running flips downstream `approved` steps to `stale` (CONTRACT.md
  §4.2/§4.3). It does **not** create a version directory.
- **CSV-only here.** This step reads `*.csv`. Excel (`.xlsx`) is not profiled — export
  to CSV, or use the published-ds route.

> The full `STATE.md` schema and the ordering / staleness / versioning rules live in
> `CONTRACT.md` at the repo root. This skill restates only its own slice; `data.py`
> is the executable mirror of the contract it enforces.
Files in this package (6)
  • SKILL.md 9 KB
  • scripts/constants.py 3 KB
  • scripts/data.py 35 KB
  • scripts/datamodel.py 17 KB
  • scripts/state.py 7 KB
  • scripts/vds.py 22 KB

Versions

The database has no other skills named tableau-data.

Database snapshot: 13.11.2026 · package version eed2ea3cbd53 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100tableau-init
    Scaffolds a new tableau-dashboard-plugin project. Creates a scaffold/ folder of demo examples (EXAMPLE-DASHBOARD-REQUEST.md, EXAMPLE-datasources.json, .env.example, branding/EXAMPLE-branding.md, starter sample-data/) and initializes the STATE.md manifest, recording the target…
  • 100tableau-route
    Router for the tableau-dashboard-plugin workflow. Reads the project's STATE.md and reports which single skill the analyst should run next, honoring the ordering rule. Use when the user asks "what's next", "where am I in the workflow", or "which tableau skill do I run now". It…
  • 100view-tableau-dashboard
    Use this skill to interact with live Tableau dashboards and views to retrieve trusted data from the visual interfaces that human users rely on for decision-making. It allows reading and applying filters, getting and setting parameters, retrieving data, and selecting marks…
  • 100query-tableau-data
    Use this skill to query Tableau data sources using HTTP to answer business questions with trusted data. It helps you explore the data catalog and construct complex queries with aggregations, filtering, calculations and more. Do not use this skill to interact with live Tableau dashboards.
  • 100tableau-next-asset-create
    Build and edit Tableau Next semantic models (SDMs), vizzes, and dashboards via MCP. TRIGGER when: building a semantic model or dashboard from CSV/Excel files; ingesting a flat file/database into DLO/DMO; profiling a dataset (grain, measures, dimensions; large/wide files via…
  • 100tableau-dagster-to-orchestra
    Use this skill when the user wants to convert a Dagster Tableau integration — TableauCloudWorkspace, TableauServerWorkspace, load_tableau_asset_specs, or build_tableau_materializable_assets_definition — into an equivalent Orchestra pipeline task targeting Tableau Cloud.…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.