---
title: Choosing between TanStack Intent and `skills`
description: "TanStack Intent vs skills: compare how each tool sources, versions, and discovers agent skills for AI coding agents, and learn when to use one, the other, or both."
url: /kb/guide/tanstack-intent-vs-skills
canonical_url: "https://vercel.com/kb/guide/tanstack-intent-vs-skills"
last_updated: 2026-06-04
authors: Ben Sabic
related:
  - /kb/guide/using-tanstack-intent-to-ship-and-consume-agent-skills
  - /changelog/introducing-skills-the-open-agent-skills-ecosystem
  - /docs/frameworks/full-stack/tanstack-start
  - /kb/guide/adding-keyboard-shortcuts-to-react-apps-with-tanstack-hotkeys
install_vercel_plugin: npx plugins add vercel/vercel-plugin
---

AI coding agents often suggest outdated patterns for a library because their training data lags behind its latest releases. Agent skills solve this by giving an agent task-specific instructions that teach it how to use a library correctly.

[TanStack Intent](https://vercel.com/kb/guide/using-tanstack-intent-to-ship-and-consume-agent-skills) and [`skills`](https://www.skills.sh/) both manage these skills, but they take different approaches to where the skills come from: Intent bundles them inside the npm packages your project already depends on, while `skills` pulls them from git repositories and surfaces them through the [skills.sh](http://skills.sh) directory.

This guide compares how each tool sources, versions, and discovers skills, then covers when to choose TanStack Intent, when to choose `skills`, and when to use both together.

> TanStack Intent is in **alpha** at the time of writing. The API may change before a stable release.

## What problem do agent skills solve?

Agent skills are an open format for extending an AI coding agent with expertise it doesn't have by default, packaged as a folder that the agent loads when a task calls for it. Because an agent's model knowledge reflects the state of a library at training time, it can recommend deprecated APIs or patterns that no longer match the installed version. Skills give the agent current, task-specific guidance to follow instead.

TanStack Intent and `skills` both get skills to your agent, but they differ in how the agent receives them.

- Intent writes a loading block into a config file your agent reads, such as [AGENTS.md](https://agents.md/) or [CLAUDE.md](https://code.claude.com/docs/en/memory#claude-md-files), and the agent loads a skill on demand by calling the Intent CLI.
  
- `skills` add them directly to your agent's skills directory (e.g., `.claude/skills`), so the agent can discover each one natively.
  

Where they really part ways is the source of the skills and how their versions keep pace with the code they describe.

## How TanStack Intent works

TanStack Intent is a CLI that ships and consumes agent skills bundled inside [npm](https://www.npmjs.com/) packages. Because a skill lives inside the package it documents, the skill's version always matches the library's installed version.

**Intent has two sides:**

- Consumers install a library that ships skills, then point their agent at the Intent CLI so the agent can list and load skills as it works.
  
- Maintainers author skills in their library repo, validate them, and publish them as part of the same npm release as their code.
  

For the consumer workflow, you run `npx @tanstack/intent@latest install` once from your project root. This writes a managed intent-skills guidance block into a supported config file (AGENTS.md by default) that tells the agent to check for skills before starting a task, load a matching skill with `intent load <package>#<skill>`, and follow the returned SKILL.md. By default, Intent discovers skills from the current project's installed dependencies, including node\_modules, workspace dependencies, and Yarn PnP projects. Global package scanning is opt-in through `--global` or `--global-only`, and local packages take precedence when both are scanned.

Maintainers scaffold a skill with `intent scaffold`, enforce format and packaging rules with `intent validate`, and wire `intent stale` into CI to catch skills that have drifted from their source docs. Because skills are versioned with library releases, running `npm update` on a dependency updates its skills at the same time.

## How `skills` works

`skills` is Vercel's [open agent skills ecosystem](https://vercel.com/changelog/introducing-skills-the-open-agent-skills-ecosystem): a CLI for installing and managing skills, plus the [skills.sh](http://skills.sh) directory and leaderboard for discovering them. You install a skill by specifying its owner and name, for example `npx skills add vercel-labs/agent-skills`, which downloads the skill(s) and installs them into your agent's skills directory. The CLI runs directly with npx, so no separate installation step is required. You can also install from a full GitHub or GitLab URL, any git URL, a path to a single skill inside a repo, or a local directory.

Skills come from git repositories rather than the npm packages your project depends on. This decouples skills from your dependency graph, so you can install any skill in the directory, even if the library it describes isn't in your project. By default, the CLI installs skills at the project level (committed with your project and shared with your team) and can install globally with the `-g` flag for use across all projects. It detects which coding agents you have installed and supports almost all of them, including [Claude Code](https://code.claude.com/docs/en/skills) and [OpenAI Codex](https://developers.openai.com/codex/skills).

The [skills.sh](http://skills.sh) directory lets you browse skills by topic (such as [GitHub](https://www.skills.sh/?q=github) or [Next.js](https://www.skills.sh/?q=next.js)), by agent, and by popularity.

Beyond the add command, the CLI covers the rest of the skill lifecycle:

- `skills list` shows what's installed
  
- `skills find` searches for skills by keyword
  
- `skills update` refreshes installed skills to their latest versions,
  
- `skills remove` uninstalls them, and
  
- `skills init` scaffolds a new SKILL.md
  

## How the two compare

Both tools add agent skills to your agent, so the practical difference lies in how skills are sourced, versioned, and discovered.

| Dimension                    | TanStack Intent                                                                                                        | `skills`                                                                                                    |
| ---------------------------- | ---------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
| Skill source                 | Bundled inside npm packages you already depend on                                                                      | Git repositories (GitHub, GitLab, any git URL, or a local path)                                             |
| How the agent gets the skill | Loading block in a config file, such as AGENTS.md or CLAUDE.md; agent loads on demand via the CLI                      | Skill folders installed into the agent's skills directory (project or global)                               |
| Discovery                    | Scans installed dependencies in the current project                                                                    | Public directory and leaderboard, plus `skills find` from the CLI                                           |
| Versioning                   | Skill version always matches the installed library version                                                             | Tracks the source repository and refresh with `skills update`. Not pinned to your installed library version |
| Primary audience             | Library maintainers who ship skills with their releases, and their consumers                                           | Anyone discovering and installing community or official skills                                              |
| Core commands                | `intent install`, `list`, `load <package>#<skill>`                                                                     | `skills add`, `list`, `find`, `update`, `remove`, `init`                                                    |
| Maintainer tooling           | Scaffold, validate, and staleness-check with `intent scaffold`, `validate`, and `stale`, then ship in your npm release | Scaffold a [SKILL.md](http://SKILL.md) with `skills init`, then publish it in a git repo                    |

## When to use TanStack Intent

Choose TanStack Intent when the version accuracy between a library and its skill matters most. Because the skill ships inside the package, updating the library updates the skill, so your agent reads guidance that matches the exact code in your node\_modules. This fits library maintainers who want their skills to travel with each release, and teams that want skill guidance scoped to the dependencies installed in a project. The tradeoff is that you only get skills for libraries that ship them through Intent, and the project is still in alpha.

## When to use `skills`

Choose `skills` when discovery and breadth matter most. The public directory, leaderboard, and the `skills find` command helps you locate skills across the whole ecosystem, including skills for tools that aren't in your dependency graph and general workflow skills that aren't tied to a single library. This fits developers who want to browse popular and official skills, install them across different agents, and add capabilities on demand. The tradeoff is that a skill isn't pinned to the installed version of the library it describes, so you review skills yourself and refresh them with `skills update`.

## Can you use both?

Yes. The two tools address different parts of the same workflow and don't conflict. You can install broad, discoverable skills with `skills` for your agent and tooling, while relying on TanStack Intent for libraries that bundle version-matched skills with their releases. Each puts skills where your agent looks for them through its own mechanism: Intent through an on-demand loading block, and `skills` by installing skill folders in your agent's skills directory.

## Resources and next steps

- Explore the skills directory at [skills.sh](http://skills.sh), and read the [skills CLI reference](https://www.skills.sh/docs/cli).
  
- Read the [TanStack Intent overview](https://tanstack.com/intent/latest/docs/overview) and the [quick start for consumers](https://tanstack.com/intent/latest/docs/getting-started/quick-start-consumers).
  
- If you maintain a library, see the [TanStack Intent quick start for maintainers](https://tanstack.com/intent/latest/docs/getting-started/quick-start-maintainers).
  
- Learn how agent skills fit into a [TanStack Start on Vercel](https://vercel.com/docs/frameworks/full-stack/tanstack-start) project.
  
- Learn more about [TanStack Intent](https://vercel.com/kb/guide/using-tanstack-intent-to-ship-and-consume-agent-skills) and [TanStack Hotkeys](https://vercel.com/kb/guide/adding-keyboard-shortcuts-to-react-apps-with-tanstack-hotkeys).