Skip to main content
skill CX Codex

tufte-report — Claude Code skill: what it does, how to install

tufte-report is a Claude Code skill that builds HTML reports with interactive charts and tables in Edward Tufte’s style, for presenting data with minimal decoration.

MIT 202 installs ★ 414 updated 2026-10-23

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add glebis/claude-skills --skill tufte-report -a claude-code
Open on GitHub

What tufte-report does

Skill generates standalone HTML files using EB Garamond for text, Monaspace Argon for numbers, Chart.js for charts, and inline SVG sparklines. Output is a document where narrative sits in the left column and data in the right — like a magazine where text and graphics share visual space.

Skill enforces limits: 8 sections max, 2 chart types per section, 3 colors per chart. Pie charts, 3D charts, and donut charts are prohibited. Every chart must have a one-sentence caption. No caption means no chart.

Builds activity dashboards, personal analytics pages, health tracker visualizations, and infographics. No build step required — one file opens in any browser.

What it helps with

  • build a report from CSV, JSON, or SQLite data
  • create a KPI dashboard with sparklines
  • visualize health tracker data
  • design a Tufte-style infographic
  • lay out a document with two-column narrative and charts

Example prompts for the agent

  • Build a Tufte-style report from metrics.csv
  • Create an activity dashboard with step and heart rate charts
  • Make an infographic from quarterly data in q4.json

How to install tufte-report

1Skills CLI (Vercel)

npx skills add glebis/claude-skills --skill tufte-report -a claude-code

2Manually: put the files in place

~/.claude/skills/tufte-report/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/tufte-report/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about tufte-report

How to install tufte-report in Claude Code?

Run npx skills add glebis/claude-skills --skill tufte-report -a claude-code, then the skill appears at ~/.claude/skills/tufte-report/SKILL.md.

What does tufte-report do?

Skill builds HTML reports with charts and tables in Edward Tufte's style: two-column layout, side narratives, high data density. Uses EB Garamond, Monaspace Argon, Chart.js, and SVG sparklines.

What data formats does tufte-report accept?

Skill works with CSV, JSON, SQLite, and API endpoints. Before generating a report, skill asks for data source and the primary question the report should answer.

Source text

SKILL.md · MIT
---
name: tufte-report
description: Create Tufte-inspired data reports and infographic dashboards as standalone HTML files. Uses EB Garamond for text, Monaspace Argon for numbers, Chart.js for interactive charts, and inline SVG sparklines. Produces publication-quality reports with 2-column narrative+data layouts, status dashboards, scroll animations, and responsive mobile support. Use this skill whenever the user wants to create a data report, activity dashboard, infographic, personal analytics page, health tracker visualization, or any document that combines narrative text with interactive charts and tables. Also triggers for "make a report like Tufte", "create an infographic", "build a dashboard", "visualize my data", or requests for beautiful data-driven documents.
---

# Tufte Report — Data-Driven Infographic Skill

Create standalone HTML reports that combine editorial narrative with interactive data visualization in Edward Tufte's style: high information density, minimal chart junk, typography-first design.

## Design Philosophy

Tufte's core principles drive every decision:
- **Data-ink ratio**: every pixel of ink should represent data, not decoration
- **Small multiples**: repeat a design to show comparison, not animation
- **Sparklines**: word-sized graphics that live inside prose
- **Layering**: overview first, then detail on demand
- **Integration**: text and graphics share the same visual space (sidenotes, not footnotes)

The report should feel like a well-edited magazine feature — you read it top to bottom, narrative carries you through the data, and every chart earns its space by answering a specific question.

## Onboarding — Ask Before Building

Before writing ANY code, ask these questions. Do not proceed until all are answered:

1. **What data sources do you have?** (CSV, JSON, SQLite, API endpoint, or raw numbers)
2. **What is the primary question this report should answer?** (one sentence — this becomes the title and drives all design decisions)
3. **How many sections do you need?** (cap at 8 — push back if more are requested; each section should answer one sub-question)
4. **What's the output format?** (standalone HTML file, or embedded component)
5. **Time budget?** Provide an estimate:
   - 1-2 sections with tables only: ~200 LOC, ~5 min bypass / ~10 min manual
   - 3-4 sections with 2-3 charts: ~500 LOC, ~15 min bypass / ~25 min manual
   - 5-8 sections with charts + health data + sparklines: ~1200 LOC, ~30 min bypass / ~50 min manual

## Scope Protection

This skill enforces hard limits to prevent scope creep:

- **Max 8 sections** — if the user asks for more, suggest combining related topics
- **Max 2 chart types per section** — a section gets one primary chart and optionally one supporting chart or table. More than that means the section should split
- **Max 3 colors per chart** — beyond that, use small multiples instead of rainbow legends
- **No 3D charts, no pie charts, no donut charts** — these violate Tufte principles
- **No gratuitous animation** — scroll-reveal on enter is fine; spinning, bouncing, or pulsing is not
- **Every chart must have a caption** — if you can't write a one-sentence caption explaining what the chart shows, the chart shouldn't exist

When the user asks for something outside these limits, respond with: "That would take the report from [current LOC estimate] to [new estimate]. The extra complexity adds [X] but risks [Y]. Shall I proceed, or can we [simpler alternative]?"

## Architecture

```
report.html (standalone, no build step)
├── Google Fonts CDN (EB Garamond)
├── jsDelivr CDN (Monaspace Argon woff2)
├── jsDelivr CDN (Chart.js 4.x UMD)
├── Inline <style> (design system CSS)
├── Inline HTML (semantic structure)
└── Inline <script> (data + Chart.js configs + sparklines + scroll-reveal)
```

No build tools, no frameworks, no npm. One file, opens in any browser.

## Design System

Read `references/design-tokens.md` for the complete CSS variables, typography scale, and color palette.

Read `references/components.md` for the HTML+CSS snippet of every reusable component.

Read `references/charts.md` for Chart.js configuration patterns and inline SVG sparkline code.

## Report Structure Template

Every report follows this skeleton:

```
1. Title + subtitle + data source tags (monospace, subtle)
2. [Optional] Status dashboard (4-column KPI strip)
3. Overview narrative with inline sparklines + TOC sidebar
4. Summary cards (2-4 KPI tiles with sparklines)
5. Sections (each: state-line → chart+narrative aside → table+narrative aside)
6. [Optional] Decision register (threshold table with status colors)
7. Footer (generation date, sources)
```

### Section Pattern

Each section follows this rhythm:
```
<h2> with ↑ back-to-top link
<p class="state-line"> — one italic sentence, the takeaway
<div class="aside-container"> — chart on left, narrative on right
<div class="aside-container"> — table on left, interpretation on right
```

The alternation of chart→narrative→table→narrative creates visual breathing room and prevents "wall of data" fatigue.

### Rules for Narrative Text

- **State-lines** (the italic intro under each heading): one sentence, max 20 words, states the conclusion not the topic. "HRV down 13%, steps down 42%" not "This section covers health metrics"
- **Aside narratives**: 3-4 short paragraphs, each starting with a bold keyword. Written like a newspaper sidebar — facts first, interpretation second
- **Flyouts**: reserved for actionable insights or methodology notes. The ✦ symbol marks them as "pay attention"
- **No "tells its own story"** or similar filler. Every sentence should contain a number or a decision

## Dual-Font Strategy

| Context | Font | Why |
|---------|------|-----|
| All body text, headers, captions | EB Garamond | Classical editorial feel, excellent readability |
| All numbers in tables | Monaspace Argon | Tabular figures align in columns, monospace scannability |
| Big numbers in cards/dashboards | Monaspace Argon | Visual weight, distinct from prose |
| Status indicators, trend percentages | Monaspace Argon | Precision signaling |
| Data source tags, code references | Monaspace Argon | Technical register |
| Ornament separators (:::) | Monaspace Argon with ligatures | Programming aesthetic, replaces floral Unicode |

## Color Principles

Use `--ink` (near-black) for text, `--bg` (warm white) for background. Chart colors must be semantically meaningful — don't assign colors randomly:

- **Orange** (`--spark-claude`, #c45a28): primary data stream, effort/work metrics
- **Green** (`--spark-wispr`, #2a7a5a): growth, positive health signals, English language
- **Purple** (`--spark-social`, #5a5aaa): social/communication metrics
- **Blue** (rgba(42,80,140)): secondary overlay lines on charts
- **Red** (#a02a2a): alerts, negative trends, declining metrics
- **Amber** (#c89000): warnings, watch-level signals
- **Green** (#2a7a3a): healthy baselines, positive trends

Never use more than 3 colors in a single chart. If you need more, use opacity/saturation variations of the same hue.

## Session Lessons (What Goes Wrong)

Based on building the reference report, these are the recurring problems:

1. **Chart.js CDN version**: Use `@4` not a specific patch version — specific versions may not exist
2. **Chart.js defaults**: Set individual properties, never replace entire objects (`Chart.defaults.scale.grid.color = '#eee'` not `Chart.defaults.scale.grid = {color: '#eee'}`)
3. **Legend circles**: Use `usePointStyle: false` with `boxWidth: 8, boxHeight: 8, borderRadius: 4` for true circles. `usePointStyle: true` creates ovals
4. **file:// protocol**: Charts won't load CDN scripts via file://. Always test via localhost
5. **Back-to-back charts**: Always separate consecutive charts with narrative, a table, or an ornament. Two charts in a row = "wall of data"
6. **Table overflow on mobile**: Wrap in `.table-wrapper` and add `.hide-mobile` to secondary columns
7. **Dual-axis charts**: Use sparingly — they invite false visual equivalence. Always label both axes clearly
8. **Narrative overreach**: Don't claim correlations without computing them. "r = 0.10" is more trustworthy than "strong relationship"

## Universal Data Adapter

When the user provides data from any source (CSV, JSON, SQLite, API, raw numbers), normalize it into the standard **ReportData** intermediate format before generating HTML. This decouples data ingestion from report rendering.

Read `references/data-adapter.md` for the ReportData JSON schema, field reference, and adapter instructions for each source type.

**Workflow:**
1. User provides data → identify source type
2. Transform into ReportData JSON (ask user for `meta.question` and desired sections)
3. Confirm the normalized structure with the user
4. Generate HTML from the ReportData using the block library

## Composable Block Library

Reports are assembled from typed blocks, each with a defined data contract. This replaces ad-hoc HTML generation with a systematic approach.

Read `references/blocks.md` for the complete block catalog: sparkline-row, kpi-card, trend-chart, data-table, correlation-matrix, narrative, heatmap, strip-chart.

Each block defines:
- **Data contract** (what JSON shape it expects)
- **HTML template** (copy-paste ready)
- **Composition rules** (how blocks pair and sequence)

## Preview Server

For iterative development, use the built-in live-reload server:

```bash
python3 ~/.claude/skills/tufte-report/scripts/serve.py report.html
```

Serves on `localhost:8042`, auto-reloads on file change with scroll position preserved. Zero dependencies — Python stdlib only.

Read `references/preview-server.md` for details. After generating a report, offer to start the preview server for the user.

© glebis · MIT · glebis/claude-skills

Similar skills

All skills for Writing and docs →
report-with-html daymade report-with-html is a Claude Code skill that builds standalone visual HTML reports, dashboards, and review workbenches. Activates on requests for browser-based reports or interactive data views. CX Codex +1 143installs storytelling-with-data sammcj storytelling-with-data is a Claude Code skill for shaping data stories and reviewing visualisations. It kicks in when a chart, dashboard, infographic or report needs a clearer message. CX Codex +1 ★ 173repo stars power-bi-report-design-consultation official github The power-bi-report-design-consultation skill guides Power BI report planning, from chart choices to page layout and accessibility. Use it when a report needs to support specific decisions for a defined audience. CX Codex +1 9,390installs build-dashboard official anthropics build-dashboard — a skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode that generates a self-contained HTML file with charts, filters, and tables. No server or runtime required — open it straight in a browser. CX Codex +1 9,700installs pdf-report-generator datadrivenconstruction The pdf-report-generator skill automates PDF report creation from construction project data. Combines charts, tables, and KPIs into a formatted document without manual assembly. CX Codex +1 132installs build-report official Data Analytics Maintainers build-report is a skill for Codex and ChatGPT that turns completed analysis into a readable, lasting report with findings, tables and caveats. CX Codex GP ChatGPT +1 4installs

From the same set51

The whole set →
context-builder context-builder — a skill for Claude Code, Codex, Cursor and other platforms that generates interactive discovery prompts for AI transformation consulting. CX Codex +1 226installs wispr-analytics wispr-analytics connects to your local Wispr Flow database to review voice dictation trends, track speech prosody, and manage custom dictionaries. CX Codex +1 218installs nano-banana The nano-banana skill generates and edits images with Gemini models, using style presets, reference images, variants, and platform sizes. Use it for thumbnails, slides, or article artwork. CX Codex +1 216installs gpt-image-2 Guides image generation through OpenAI's GPT Image 2 API using structured style presets, cost-saving drafts, and automated prompt validation. CX Codex +1 213installs temple-generator temple-generator converts any Obsidian markdown vault into an interactive 3D Three.js knowledge visualization with multi-scale semantic zoom and audio. CX Codex +1 199installs meeting-processor meeting-processor processes meeting transcripts from Fathom and Granola, detects meeting types, and extracts structured takeaways. CX Codex +1 195installs session-search session-search is a Claude Code skill that finds past sessions by meaning, keywords, and related concepts. Find earlier debugging work or research. CX Codex +1 192installs browsing-history Search browsing history by time, device, domain, or keywords. Group results and print them or save them as Markdown or JSON. CX Codex +1 188installs

Project sponsors

Companies that keep this analytics open