A Vibe Coding Stack for a Data Analyst

Most vibe-coding stacks in this series are built for people shipping software. A data analyst is doing something narrower but no less real: pulling numbers out of a database, turning them into a report someone else will read, and doing it again next week with fresh data. That job has different priorities than app-building. You care less about deploy pipelines and more about getting a query right, catching a bad join before it reaches a slide deck, and producing a workbook a manager can open without asking what a .csv is.

The good news is that the same agent and the same MCP idea that power a coding stack work just as well here — you're just pointing them at a database and a spreadsheet instead of a repo and a deploy target. This post puts together one such stack: one app, three skill or subagent packs, and three MCP servers pulled from three different categories, all listed in the ecosystem already.

The app: something that can read, query and write files

For this stack the app doing the driving is {{tool:claude-code}}. The reason isn't brand loyalty — it's that an analyst's day involves a lot of file types: SQL, CSV exports, Excel workbooks, the odd Jupyter notebook, and a written summary at the end. Claude Code runs from a terminal or an IDE, reads and writes any of those formats directly, and — critically for this stack — is the app every skill and MCP server below documents support for first. It also happens to be the most open of the mainstream apps about how you connect data: Agent Skills, subagents, MCP servers and CLAUDE.md project instructions all load into the same session — see its MCP servers page for the full list this directory tracks.

Install it the way its own docs describe:

curl -fsSL https://claude.ai/install.sh | bash

Once it's running in a project folder, the rest of this stack layers on top: skills for know-how, a subagent pack for delegation, and MCP servers for the actual data connections.

Skills: document output and a research library

An analyst produces two kinds of thing: analysis, and the document that reports it. {{tool:anthropic-skills}} covers the second half well — it's Anthropic's own skill collection, and the docx, pdf, pptx and xlsx skills inside it are the same ones behind Claude's built-in file creation. Installed as a plugin, they let the agent write a real Word doc or a formatted workbook instead of dumping a markdown table you have to reformat by hand.

/plugin marketplace add anthropics/skills
/plugin install document-skills@anthropic-agent-skills

For the analysis side, {{tool:claude-scientific-skills}} is a much bigger, more specialized library: at last count, 166 skills covering statistics, visualization and domain-specific research methods, plus access to more than 100 scientific databases. Most analysts won't need the bioinformatics or cheminformatics skills in there, and the maintainers themselves recommend installing a topical subset rather than everything — both to keep the agent's context small and because, as a large community-fed collection, not every skill has been reviewed equally closely.

npx skills add K-Dense-AI/scientific-agent-skills

Pick the statistics and visualization skills you actually use and leave the rest uninstalled.

A specialist bench: subagents for the heavier lifting

Not every task deserves the same amount of reasoning. Checking that a CSV loaded correctly is a quick job; designing a cohort analysis query is not. {{tool:wshobson-agents}} is a plugin marketplace built around that distinction — roughly 200 specialist subagents across 94 plugins, each assigned a model tier so quick operational work runs on a cheaper model and harder reasoning gets routed to a stronger one. Because every plugin is self-contained, installing one doesn't load the other 93 into your context.

/plugin marketplace add wshobson/agents
/plugin install python-development

That example plugin bundles Python-focused agents and skills together, which is the more common case for an analyst than reaching for the full marketplace. The project also generates output for other harnesses (Codex CLI, Cursor, OpenCode) from the same source, so it isn't a Claude Code lock-in if the rest of your team uses something else.

MCP servers: the database, the spreadsheet and the web

This is where the stack actually touches data, and it's worth pulling servers from three different MCP categories rather than stacking three database tools.

For the database itself, {{tool:neon-mcp}} is Neon's official server for serverless Postgres. An agent can inspect schema, run SQL, and — its standout feature — test a schema change on a temporary branch before merging it into the branch you actually query from. It's free to use with a Neon account, and it ships a safety switch: append ?readonly=true to the connection URL, or untick "Allow writes" at sign-in, to drop every write tool and restrict run_sql to read-only queries. That's the setting worth turning on for a stack whose whole job is reading numbers, not changing them.

npx add-mcp https://mcp.neon.tech/mcp

For output, {{tool:excel-mcp-server}} creates, reads and edits real .xlsx files without Excel installed — writing data into ranges, adding formulas, building pivot tables and charts, all from the agent. It runs locally through uvx:

uvx excel-mcp-server stdio

Because it edits files in place, keep a copy of anything you can't afford to lose, and if you run the HTTP transport instead of stdio, set EXCEL_FILES_PATH so the server can't write outside a folder you've chosen.

For everything outside your own database — checking a number against a public report, or pulling a competitor's published figures — {{tool:tavily-mcp}} adds real-time web search and page extraction built specifically for LLM consumption. The hosted server needs no local install:

claude mcp add --transport http tavily https://mcp.tavily.com/mcp

Tavily's free plan includes 1,000 API credits a month with no card required, which is plenty for occasional lookups; a few tavily_crawl calls will burn through that faster than search alone, so set limits on crawl depth if you turn it on.

Putting it together: a Tuesday morning workflow

Concretely, a session might look like this: Claude Code opens with CLAUDE.md describing the project's tables and typical joins. You ask for last week's signup-to-activation funnel; the agent uses the Neon MCP server (read-only) to inspect the schema and run the query, hands the numbers to a scientific-skill for a quick statistical check on whether the week-over-week change is noise, then uses the Excel MCP server to write a formatted workbook with a chart. If a number looks off against a public benchmark, it reaches for Tavily to check. The whole thing produces a .xlsx file and a short written summary — using the document skill from anthropic-skills — that's ready to attach to an email, not a chat transcript you have to clean up first.

What it costs per month

At the free tiers, the only recurring cost is Claude Code itself. That's a deliberately conservative estimate — a bigger warehouse than Neon's free Postgres, or search volume past Tavily's 1,000 monthly credits, will add usage-based cost on top. Check deals before paying full price on any of these; discounts change and this directory tracks the ones that are currently verified.

Guardrails before you connect real data

Two things are worth doing before pointing any of this at a real database. First, use Neon's read-only mode rather than trusting the agent to only run SELECT statements — it's an actual switch, not a suggestion, and it also restricts run_sql itself. Second, treat the scientific-skills library the way its own maintainers describe it: install a named subset instead of all 166 skills, since skills in that collection can install packages and call external APIs, and a large community-contributed set hasn't all been reviewed to the same depth. Neither step takes more than a minute, and both turn "an agent with database and internet access" into something you'd actually let near a real report.

Swapping pieces without breaking the shape

The specific tools here matter less than the pattern: one app that can load skills, subagents and MCP servers in the same session; a document-formatting skill so output doesn't need manual cleanup; a subagent layer for delegating the harder reasoning; and exactly one MCP server per real capability. If your data lives in MySQL instead of Postgres, mcp-server-mysql slots into the same spot as neon-mcp with a similar read-only-by-default posture. If your team is already on Cursor rather than Claude Code, most of the pieces above are documented against it too — check each listing's "works with" section before assuming. And if web lookups aren't part of your job, dropping Tavily entirely still leaves a complete, working stack; nothing here depends on all seven pieces being present at once.

The one substitution to be careful with is the skills library. claude-scientific-skills is deliberately broad because it serves researchers as much as analysts, so treat the install command as a starting point for picking a handful of relevant skills, not an instruction to add all 166 at once.

Takeaway

None of these seven pieces are exotic — a mainstream coding agent, two skill packs, one subagent marketplace, and three MCP servers each solving one problem. The part worth copying is the shape: one server per real capability (query, write, search) rather than three overlapping database tools, read-only turned on by default, and a document skill doing the last-mile formatting so the output is something you hand off, not something you still have to finish.