Skip to main content
skill CX Codex

nx-run-tasks — Claude Code skill for running Nx tasks

Tells the agent how to run build, test, lint and serve targets in an Nx workspace. Useful when a monorepo has more projects than you can track.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add nrwl/nx-ai-agents-config --skill nx-run-tasks -a claude-code
Open on GitHub

What nx-run-tasks does

The skill covers how tasks work in an Nx workspace. The agent first checks which targets exist, then picks the right command. You can list them with nx show project <projectname> --json — the response has a targets section. The skill also suggests reading package.json or project.json, but warns that this misses tasks inferred by Nx plugins.

A single target runs as nx run <project>:<task>. Several at once go through nx run-many -t build test lint typecheck, with -p, --exclude and --parallel to narrow things down. For large repos and CI there is nx affected, which only touches changed projects and their dependents, comparing against the base branch by default.

One wrinkle is invocation. If nx is not installed globally, the command needs an npx, pnpx or yarn prefix — the skill has the agent figure out the package manager from package.json or the lockfile, so a machine without a global Nx will not trip it up. The same flags work across all three modes: --skipNxCache to rerun anyway, --verbose for stack traces, --nxBail to stop at the first failure, --configuration=<name> for a specific configuration.

What it helps with

  • build a single project inside a monorepo
  • run tests and lint across several packages at once
  • build only the projects changed in CI
  • rerun a task while bypassing the Nx cache
  • stop a run after the first failed task

Example prompts for the agent

  • build the myapp project
  • run tests and lint for every project tagged api-*
  • run an affected build against the main branch

How to install nx-run-tasks

1Skills CLI (Vercel)

npx skills add nrwl/nx-ai-agents-config --skill nx-run-tasks -a claude-code

2Manually: put the files in place

~/.claude/skills/nx-run-tasks/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/nx-run-tasks/

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

Questions about nx-run-tasks

How do I install nx-run-tasks in Claude?

Run npx skills add nrwl/nx-ai-agents-config --skill nx-run-tasks -a claude-code. The skill file lands at ~/.claude/skills/nx-run-tasks/SKILL.md.

What does nx-run-tasks do?

It teaches the agent how to run tasks in an Nx workspace: single targets with nx run, batches with nx run-many, and only changed projects with nx affected.

Do I need Nx installed globally?

No. The skill tells the agent to detect the package manager from package.json or the lockfile and prefix the command with npx, pnpx or yarn when needed.

Source text

SKILL.md · MIT
---
name: nx-run-tasks
description: Helps with running tasks in an Nx workspace. USE WHEN the user wants to execute build, test, lint, serve, or run any other tasks defined in the workspace.
---

You can run tasks with Nx in the following way.

Keep in mind that you might have to prefix things with npx/pnpx/yarn if the user doesn't have nx installed globally. Look at the package.json or lockfile to determine which package manager is in use.

For more details on any command, run it with `--help` (e.g. `nx run-many --help`, `nx affected --help`).

## Understand which tasks can be run

You can check those via `nx show project <projectname> --json`, for example `nx show project myapp --json`. It contains a `targets` section which has information about targets that can be run. You can also just look at the `package.json` scripts or `project.json` targets, but you might miss out on inferred tasks by Nx plugins.

## Run a single task

```
nx run <project>:<task>
```

where `project` is the project name defined in `package.json` or `project.json` (if present).

## Run multiple tasks

```
nx run-many -t build test lint typecheck
```

You can pass a `-p` flag to filter to specific projects, otherwise it runs on all projects. You can also use `--exclude` to exclude projects, and `--parallel` to control the number of parallel processes (default is 3).

Examples:

- `nx run-many -t test -p proj1 proj2` — test specific projects
- `nx run-many -t test --projects=*-app --exclude=excluded-app` — test projects matching a pattern
- `nx run-many -t test --projects=tag:api-*` — test projects by tag

## Run tasks for affected projects

Use `nx affected` to only run tasks on projects that have been changed and projects that depend on changed projects. This is especially useful in CI and for large workspaces.

```
nx affected -t build test lint
```

By default it compares against the base branch. You can customize this:

- `nx affected -t test --base=main --head=HEAD` — compare against a specific base and head
- `nx affected -t test --files=libs/mylib/src/index.ts` — specify changed files directly

## Useful flags

These flags work with `run`, `run-many`, and `affected`:

- `--skipNxCache` — rerun tasks even when results are cached
- `--verbose` — print additional information such as stack traces
- `--nxBail` — stop execution after the first failed task
- `--configuration=<name>` — use a specific configuration (e.g. `production`)

© nrwl · MIT · nrwl/nx-ai-agents-config

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set6

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor