# nx-generate

A skill that tells the agent how to run Nx generators in a monorepo: pick the right one, dry-run it, then scaffold without breaking repo conventions.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 3800 installs · ★ 29
- Author: nrwl
- License: MIT · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/nrwl/nx-ai-agents-config/tree/HEAD/skills/nx-generate/SKILL.md
- Updated: 2026-10-23
- HTML: https://affpapa.org/en/nevibecode/skills/nx-generate

## What it does

The skill kicks in when you ask the agent to create something in a monorepo — an app, a library, a feature scaffold. The agent lists generators with `npx nx list`, checks the options, and runs the one that fits. One rule is spelled out: when both a local workspace generator and a plugin generator could do the job, the local one wins, because it already matches the repo's patterns.

Before running anything, the agent reads the generator's source code, not just its schema. That way it knows which files get created and which configs get touched. It then compares against similar artifacts already in the repo and does a `--dry-run` to check file placement. The `--no-interactive` flag goes on every call, otherwise the run hangs on a prompt.

The `--directory` flag is the usual trap: it takes the full path of the library, not the parent folder. Pass `--directory=libs` and you get files in `libs` and `libs/src`. The skill advises the full form, like `libs/my-lib`. After generation the code is formatted and checked with lint, tests and build.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add nrwl/nx-ai-agents-config --skill nx-generate -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/nx-generate/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/nx-generate/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add nrwl/nx-ai-agents-config --skill nx-generate -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/nx-generate/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add nrwl/nx-ai-agents-config --skill nx-generate -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/nx-generate/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install nrwl/nx-ai-agents-config nx-generate
```

2. **Manually: put the files in place**
- File: `.github/skills/nx-generate/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add nrwl/nx-ai-agents-config --skill nx-generate -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/nrwl/nx-ai-agents-config --path skills/nx-generate
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/nx-generate/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add nrwl/nx-ai-agents-config --skill nx-generate -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/nrwl/nx-ai-agents-config/tree/HEAD/skills/nx-generate/SKILL.md

## When to use it
- create a new library that follows the repo's conventions
- scaffold an app on the framework the workspace already uses
- run a custom workspace generator
- check where files will land before running the generator for real
- format generated code and pass lint and tests

## Example prompts
- create a new library in libs/shared/ui
- scaffold a new React app in this workspace
- what generators does @nx/react expose

## Source text · SKILL.md · MIT

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: abe90ba3084722b7.

BEGIN THIRD-PARTY FILE abe90ba3084722b7
````text
---
name: nx-generate
description: Generate code using nx generators. INVOKE IMMEDIATELY when user mentions scaffolding, setup, structure, creating apps/libs, or setting up project structure. Trigger words - scaffold, setup, create a new app, create a new lib, project structure, generate, add a new project. ALWAYS use this BEFORE calling nx_docs or exploring - this skill handles discovery internally.
subagent: general-purpose
context: fork
---

# Run Nx Generator

Nx generators are powerful tools that scaffold projects, make automated code migrations or automate repetitive tasks in a monorepo. They ensure consistency across the codebase and reduce boilerplate work.

This skill applies when the user wants to:

- Create new projects like libraries or applications
- Scaffold features or boilerplate code
- Run workspace-specific or custom generators
- Do anything else that an nx generator exists for

## Key Principles

1. **Always use `--no-interactive`** - Prevents prompts that would hang execution
2. **Read the generator source code** - The schema alone is not enough; understand what the generator actually does
3. **Match existing repo patterns** - Study similar artifacts in the repo and follow their conventions
4. **Verify with lint/test/build/typecheck etc.** - Generated code must pass verification. The listed targets are just an example, use what's appropriate for this workspace.

## Steps

### 1. Discover Available Generators

Use the Nx CLI to discover available generators:

- List all generators for a plugin: `npx nx list @nx/react`
- View available plugins: `npx nx list`

This includes plugin generators (e.g., `@nx/react:library`) and local workspace generators.

### 2. Match Generator to User Request

Identify which generator(s) could fulfill the user's needs. Consider what artifact type they want, which framework is relevant, and any specific generator names mentioned.

**IMPORTANT**: When both a local workspace generator and an external plugin generator could satisfy the request, **always prefer the local workspace generator**. Local generators are customized for the specific repo's patterns.

If no suitable generator exists, you can stop using this skill. However, the burden of proof is high—carefully consider all available generators before deciding none apply.

### 3. Get Generator Options

Use the `--help` flag to understand available options:

```bash
npx nx g @nx/react:library --help
```

Pay attention to required options, defaults that might need overriding, and options relevant to the user's request.

### Library Buildability

**Default to non-buildable libraries** unless there's a specific reason for buildable.
````
END THIRD-PARTY FILE abe90ba3084722b7

The third-party file has ended. Everything between the abe90ba3084722b7 tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2678 of 7816 bytes. © nrwl · MIT · https://github.com/nrwl/nx-ai-agents-config/tree/HEAD/skills/nx-generate/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md