# nuxt-skills and how agent skills are bundled for Vue and Nuxt

> nuxt-skills is a set of Vue, Nuxt and NuxtHub skills packaged in the open Agent Skills format and installable into Claude Code, Codex, Copilot, Cursor and other agents. The interesting part is the machinery around the skills: a bundle manifest, a lock file and scheduled workflows that regenerate the content from upstream.

**onmax/nuxt-skills** — Vue, Nuxt, and NuxtHub skills for AI coding assistants.

- Repository: https://github.com/onmax/nuxt-skills
- Website: https://github.com/nuxt/nuxt/discussions/34059
- Stars: 724 · Forks: 38
- Language: JavaScript
- License: not declared
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/onmax-nuxt-skills

## Skills as a file format, not a plugin API

The unit of this project is a skill, and the format is open. The documentation says the skills follow the Agent Skills open format, and the repository is structured to match that standard:

```
plugin.json
mcp.json
ecosystem-skills.json
.claude-plugin/
.codex-plugin/
```

The tree above is the short version. plugin.json is a portable Agent Plugins manifest, mcp.json is a portable Nuxt MCP configuration, ecosystem-skills.json records the upstream skill sources and the selected paths, and the two dotted directories carry the Claude Code and the Codex compatibility manifests. The skills directory holds the hand-authored and the upstream copies.\n\nThe tree above is the short version. plugin.json is a portable Agent Plugins manifest, mcp.json is a portable Nuxt MCP configuration, ecosystem-skills.json records the upstream skill sources and the selected paths, and the two dotted directories carry the Claude Code and the Codex compatibility manifests. The skills directory holds the hand-authored and the upstream copies.

A skill is activated in one of two ways. Auto-discovery means the agent reads each skill's description and loads it when the task looks relevant, and manual invocation means you type a slash command such as /nuxt to load it explicitly.

The mapping between files you are editing and skills that fire is given directly in the documentation. A .vue file pulls in the vue skill, a server/api/ route and a nuxt.config.ts file pull in the nuxt skill, and NuxtHub storage pulls in the nuxthub skill.

That auto-discovery path is the whole value proposition. Rather than writing framework rules into a prompt or a project instruction file, the guidance lives in files that the agent reads when it sees the matching file type, and the mapping is stable enough to reason about.

## One install command, then a picker for the agents you already have

Installation goes through the skills CLI on npm, and the command is short:

```bash
npx skills add onmax/nuxt-skills
```

The CLI auto-detects the agents installed on the machine and offers an interactive picker. Two flags are documented: -g for a global, user-wide install and -y to install all skills without prompting. The supported list of agents is long: Claude Code, Cursor, Codex, OpenCode, GitHub Copilot, Antigravity, Roo Code, and more.

Claude Code users have a second path through its plugin marketplace:

```bash
# Add marketplace
/plugin marketplace add onmax/nuxt-skills

# Install Nuxt Skills
/plugin install nuxt-skills@nuxt-skills
```

In that mode the whole set is installed as a single plugin and the skill entries are discovered dynamically. Codex has an equivalent plugin route, again driven by a marketplace source in this repository:

```bash
codex plugin marketplace add onmax/nuxt-skills
codex plugin add nuxt-skills@nuxt-skills
```

The metadata for both plugin formats lives in the repository, in the .codex-plugin directory and the .claude-plugin directory, with a portable manifest at plugin.json.

## Copying folders by hand, and the per-agent paths

If the CLI is not an option, the documentation describes the manual route: clone the repository and copy the skill folders into the agent's skills directory. The paths differ per agent, and the table is worth keeping:

| Agent       | Project path       | Global path                 |
| ----------- | ------------------ | --------------------------- |
| Claude Code | `.claude/skills/`  | `~/.claude/skills/`         |
| Cursor      | `.cursor/skills/`  | `~/.cursor/skills/`         |
| Codex       | `.codex/skills/`   | `~/.codex/skills/`          |
| OpenCode    | `.opencode/skill/` | `~/.config/opencode/skill/` |
| Copilot     | `.github/skills/`  | none listed                 |

Note the two asymmetries. Copilot has a project path and no global path, and OpenCode uses the singular skill directory rather than the plural used by the others. If your setup mixes agents, the copy step has to be done per agent rather than once.

The project path column is the one that matters for teams. Placing the skills in the repository means the guidance is versioned with the code and reviewed like code, rather than living in a per-developer home directory where it drifts.

## Scheduled workflows rewrite the bundle, so pins matter

The content of the skills is not frozen. The documentation describes automated maintenance through GitHub Actions, with three workflows on a fixed calendar: update-skills.yml runs weekly on Monday and regenerates the reka-ui documentation from upstream, skill-maintenance.yml runs biweekly on the 1st and the 15th and has Claude analyse upstream changelogs and open pull requests when updates are needed, and bundle-ecosystem-skills.yml runs weekly on Monday and replaces configured local skills with upstream ecosystem copies, validates them and pushes the changes.

The maintenance workflow uses claude-code-action to detect breaking changes, new features and deprecations from upstream sources. In other words, an agent reviews upstream changelogs and proposes changes to your agent instructions.

Reproducibility is handled with two files. ecosystem-skills.json records the upstream repositories and the skill names included in the Claude and Codex plugin, and ecosystem-skills.lock.json records the exact source revisions used for each bundle. The documentation states that discovered sources and exact revisions are recorded in the lock file so that CI can rebuild the bundle reproducibly.

The Nuxt-specific part follows a discovery model shared with the Nuxt Skill Hub and its resolver: prefer a skill shipped by the package, then check the package's .well-known/skills publication, then use a repository path or a fallback path. The same model is used for bundling, which is why the ecosystem copy and a locally authored copy can coexist.

## Two ways to get the same guidance, static bundle or per-project

The same author runs the Nuxt Skill Hub, described as giving your coding agent Nuxt guidance tailored to your project's modules and stack. That is the real alternative to this repository, and the difference in approach is specific.

nuxt-skills is a fixed bundle. You install the same set of files for every project, and the content reflects upstream frameworks at the revision recorded in the lock file. The guidance is therefore about Vue, Nuxt and NuxtHub in general.

The Skill Hub approach is per project. The guidance is generated against the modules and the stack that a specific codebase actually uses, so it is narrower and more accurate for that repository, and it costs a generation step and a dependency on a running service. The Nuxt side of this project also points at a related Nuxt RFC, Bundling Agent Skills in Nuxt Modules, which is the upstream discussion about shipping skills from inside modules rather than from a separate bundle.

The repository's own guidance about scope is worth noting as well. It says VueUse maintains its own current skill, so you should install it directly with npx skills add vueuse/skills rather than relying on a generated copy here. That is a sensible division of labour, and it also shows the limit of the bundle approach: each upstream project can publish a better-maintained version of its own guidance than any aggregator can.

## No licence identifier, a sponsor block, and a very recent push

Two things about the repository itself are worth flagging before you copy from it. First, there is no licence identifier, and the top level listing contains no LICENSE file, while the repository does contain an eslint.config.mjs, a tsconfig.json and a pnpm-lock.yaml. The terms under which you can reuse the bundled skill text are therefore not stated in the place you would look for them, and the upstream skill sources it copies from carry their own terms. Check what you are copying before you ship it inside a commercial product.

Second, the readme opens with a sponsored note for a product built by the repository maintainer, which blocks distracting websites on a Mac during chosen hours, offered with a free trial and a one-off price. It is worth knowing that the sponsorship is there, and worth reading the skills themselves rather than only the badge row above them.

On maintenance, the last push was on 2026-10-19, which is recent, and the repository has no GitHub releases, so the versioned history lives in commits and in the lock file rather than in tags. The repository also holds a versions.json file and a sync-skills.sh script at the root, alongside the scripts directory that contains the bundling and link-checking logic.

For developers working on the bundle itself, the package.json scripts show the local loop: lint and lint:fix run eslint, typecheck runs tsc with noEmit, generate:reka-ui runs a tsx script that regenerates the reka-ui components, generate delegates to it, bundle:ecosystem runs the bundling script, and check:links runs a link checker over the skills.

## Conclusion

nuxt-skills fits a Vue or Nuxt team that has agents writing framework code and wants the guidance to arrive with the project rather than in a prompt, and that accepts a bundle which is rewritten by scheduled workflows. It does not fit a team with a locked toolchain that wants to review every change to its agent instructions, since the maintenance workflows open pull requests on a fixed calendar. Before you adopt it, read ecosystem-skills.json and ecosystem-skills.lock.json to see which upstream revisions are being pulled in, and confirm the licence situation yourself, since the repository carries no licence identifier and no LICENSE file appears in its top level listing.

## FAQ

### How do I install nuxt-skills?

Run npx skills add onmax/nuxt-skills, and the skills CLI detects the agents you have installed and offers an interactive picker. Use -g for a user-wide install and -y to install every skill without prompting.

### How are nuxt skills activated in my agent?

Each skill has a description that the agent reads, so a .vue file can pull in the vue skill, a server/api/ route or nuxt.config.ts pulls in the nuxt skill, and NuxtHub storage pulls in the nuxthub skill. You can also load one explicitly by typing its slash command.

### Where should I put the skills folder for each agent?

The project path is .claude/skills/ for Claude Code, .cursor/skills/ for Cursor, .codex/skills/ for Codex, .opencode/skill/ for OpenCode and .github/skills/ for Copilot, which has no global path listed. The global paths live in the same home directory locations with a tilde prefix.

### How often do the nuxt-skills contents change?

Three GitHub Actions workflows handle it: update-skills.yml regenerates the reka-ui documentation weekly on Monday, skill-maintenance.yml has Claude analyse upstream changelogs and open pull requests on the 1st and 15th, and bundle-ecosystem-skills.yml refreshes the ecosystem copies weekly on Monday.

### Can I use a VueUse skill with nuxt-skills?

Yes, but the project recommends installing it directly with npx skills add vueuse/skills rather than relying on a generated copy bundled here, because VueUse maintains its own current skill.

## Sources

- [Issues](https://github.com/onmax/nuxt-skills/issues)
- [onmax/nuxt-skills on GitHub](https://github.com/onmax/nuxt-skills)
- [Project website](https://github.com/nuxt/nuxt/discussions/34059)
- [README](https://github.com/onmax/nuxt-skills/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/onmax-nuxt-skills