Best AI Agent Skills for Data Pipelines & ETL in 2026

Every data pipeline has a boring 80% and a cursed 20%. The boring part (Postgres to Snowflake, Stripe to your warehouse) is solved; a managed connector handles it and you never think about it. The cursed 20% is where your week goes: the supplier who sends a 14-tab Excel file with merged cells, the internal API nobody wrote a connector for, the website you have to scrape because there's no export. Agent skills are built for that 20%.

A skill is a packaged procedure you install into a coding agent like Claude Code. Instead of explaining "here's how we parse the vendor's spreadsheet" every single time, you install the skill once and the agent loads it when the task fits. Below are the ones doing real ETL work in 2026, grouped by pipeline stage, with the security notes you actually need before installing.

Quick comparison

Extract: getting data out of awkward places

xlsx-spreadsheet: the unglamorous workhorse

Most pipeline pain in 2026 is still a spreadsheet. The xlsx skill teaches the agent to open real-world Excel files: the ones with merged header cells, a summary tab, three data tabs, and a "notes" column someone typed prose into. You point it at the file, describe the shape you want, and it writes the extraction logic and hands you clean tabular output.

Why it matters for ETL: the agent doesn't just dump the cells, it reasons about structure. It figures out that rows 1 through 3 are a merged title, that the real header is row 4, that the last two rows are totals to drop. That structural read is exactly what brittle, hardcoded parsers get wrong the moment the vendor reshuffles a column.

Install: clone into your skills directory and restart the agent. Security: it reads and writes files on your machine, which is low risk, but point it at a copy of the source file, not your only one.

firecrawl-skill: when there's no API

Some sources only exist as web pages. The firecrawl skill gives the agent a clean way to pull a page's content as structured markdown or JSON, which beats hand-rolling BeautifulSoup for the hundredth time. For pipelines that ingest from documentation sites, public listings, or a competitor's pricing page, this is the extract step.

Security note that matters: this skill makes outbound web requests, and it may use a hosted API with a key. Know what you're scraping (respect terms of service and rate limits), and keep the API key out of your repo.

playwright-mcp: for sites that fight back

When firecrawl isn't enough (a login wall, a dashboard that renders with JavaScript, a "click to load more" list), the playwright skill drives an actual browser. It's heavier and slower, so reach for it only when a simple fetch fails. For internal tools with no API, it's often the only way to get the data without begging another team for database access.

Security: it controls a browser that may be logged into your accounts. Run it against staging or a throwaway session before anything sensitive.

Transform: reshaping into something usable

The transform stage is where the xlsx skill earns its second mention, because most transformation in small-to-mid pipelines is still spreadsheet-shaped: pivot this, unstack that, join the lookup tab, standardize the date column. The agent writes the pandas or SQL, you review it, you run it. The win isn't that AI invents a transform you couldn't. It's that it writes the tedious reshape code in 30 seconds and you spend your attention on whether the logic is right.

A pattern worth adopting: ask the skill to generate a reusable script, not a one-time edit. Next month's file from the same vendor runs through the same script. You're building a pipeline, not doing a chore twice. And always check the row count before and after a transform. A join that silently drops rows is the single most common way an agent-written reshape goes wrong without throwing an error.

Connect: building the connector that doesn't exist

mcp-builder: for the source with no off-the-shelf connector

This is the skill with the biggest payoff on the list, and the one to handle most carefully. When you have an internal API or an obscure SaaS with no Airbyte connector, mcp-builder scaffolds a Model Context Protocol connector so your agent (and your pipeline) can talk to it directly. It generates the boilerplate, the auth handling, the tool definitions.

This is also where the risk climbs. The skill generates running code that touches a live source. Review every line before you run it, start with read-only credentials, and test against a non-production endpoint. A connector that works is great; a connector that silently writes to production because you skimmed the generated code is a bad afternoon.

Enrich and validate: the steps people skip

deep-research: filling the gaps with citations

Pipelines often need enrichment: map a company name to an industry, find a missing country code, attach context a raw feed doesn't carry. The deep-research skill runs a multi-source web pass and returns findings with citations, which is what separates it from a model just guessing. For an enrichment step where being wrong has consequences, the citation trail lets you verify instead of trust.

It's read-only, so the install risk is low. The discipline is using the citations. Enrichment that nobody checks is just confident noise in your warehouse.

How to actually adopt these

Don't install all five and hope. A sane order:

1. Start with xlsx-spreadsheet. It pays off on day one because everyone has a cursed spreadsheet. 2. Add an extractor (firecrawl or playwright) only when you hit a source with no export. 3. Reach for mcp-builder when you've manually glued the same custom source three times. That's the signal to build a real connector. 4. Layer deep-research for enrichment steps where accuracy is non-negotiable.

For the broader engineering picture (orchestration, testing, the skills that complement these), see our full list for data scientists, which overlaps heavily with data-engineering work.

The security rule that ties it together

Every skill here can run code or reach a live system. Treat installing one like onboarding a contractor: read the SKILL.md and any bundled scripts first, scope credentials to the narrowest access that does the job, and test against staging before production. Skills are open folders, so you can and should read them. The teams that get burned are the ones who installed a skill they never opened.

The bottom line

Managed ETL tools own the repeatable 80%, and you shouldn't fight that. Agent skills win the cursed 20%: the weird files, the connector-less sources, the enrichment nobody automated. Install xlsx first, add the others when a real source forces your hand, and read every skill before you trust it with your data.

FAQ

What are AI agent skills for data pipelines?

They are packaged instruction sets that teach a coding agent like Claude Code how to do a specific pipeline task: read a spreadsheet, scrape a source, scaffold an MCP connector, or run a research pass. You install them once, and the agent loads the skill when the task matches, instead of you re-explaining the procedure every time.

Are agent skills better than a dedicated ETL tool like Airbyte?

They solve different problems. Airbyte and Fivetran are managed connectors for known, recurring source-to-warehouse syncs. Agent skills shine on the messy edges: a one-off scrape, a weird Excel file, a custom API with no connector, glue logic between steps. Most teams in 2026 run both: a managed tool for the boring 80%, skills for the long tail.

How do I install a data pipeline skill in Claude Code?

Most skills are a folder with a SKILL.md file. You clone the repo into your skills directory (or use a marketplace install command), restart the agent, and it picks up the skill automatically when your request matches the skill description. Always read the SKILL.md and any scripts before installing, because a skill can run code on your machine.

Is it safe to give an agent skill access to my database?

Only with guardrails. Give it a read-only credential first, run it against a staging copy, and review what it generates before pointing it at production. A skill that builds an MCP connector or runs SQL has real reach. The security model is the same as hiring a contractor: scope the access to the job.