К основному содержанию
скилл CX Codex

rspack-split-chunks — скилл для Claude Code: диагностика splitChunks

Скилл rspack-split-chunks помогает агенту диагностировать и настраивать optimization.splitChunks в Rspack: найти дубликаты модулей, избыточную загрузку, проблемы кеширования и слишком большие чанки.

MIT 187 установок ★ 100 обновлён 2026-10-22

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add rstackjs/agent-skills --skill rspack-split-chunks -a claude-code
Открыть на GitHub

Что делает rspack-split-chunks

Скилл учит агента разбираться в конфигурации splitChunks Rspack и объясняет, как параметры влияют на граф чанков. Агент проверяет, не используется ли фиксированный name там, где он заставляет роуты загружать лишние модули, и различает умолчания репозитория от продакшн-базы. Для большинства случаев рекомендуется chunks: "all" без дополнительных групп.

Внутри скилла — инструкции по анализу дубликатов модулей, настройке кеш-групп и разделению больших чанков через maxSize. Агент использует референсы из references/repo-behavior.md, когда нужно обосновать рекомендацию. Скилл не трогает tree shaking и порядок выполнения JavaScript — это решается в других частях конфига.

Какие задачи решает

  • найти дубликаты модулей через границы entry и async
  • убрать лишние модули из shared-чанков
  • настроить кеш-группы для стабильного кеширования
  • разделить слишком большой vendor-чанк
  • проверить, не сломает ли chunks: "all" порядок загрузки

Примеры запросов агенту

  • Почему роут загружает модули из других роутов?
  • Как разделить vendors.js на несколько чанков без имён?
  • Проверь конфиг splitChunks — что здесь рискованно?

Как установить rspack-split-chunks

1Через Skills CLI (Vercel)

npx skills add rstackjs/agent-skills --skill rspack-split-chunks -a claude-code

2Вручную: положить файлы

~/.claude/skills/rspack-split-chunks/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/rspack-split-chunks/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы о rspack-split-chunks

Как установить rspack-split-chunks в Claude Code?

Запусти npx skills add rstackjs/agent-skills --skill rspack-split-chunks -a claude-code, скилл установится в ~/.claude/skills/rspack-split-chunks/SKILL.md.

Что делает скилл rspack-split-chunks?

Учит агента диагностировать конфигурацию optimization.splitChunks в Rspack: находить дубликаты модулей, проверять кеш-группы, разделять большие чанки и объяснять, как параметры влияют на граф.

Почему скилл рекомендует chunks: "all"?

Это позволяет splitChunks дедуплицировать модули через границы initial и async, но при этом загружаются только чанки, достижимые из текущего entry. Обычно это безопаснее глобальных vendor-бакетов с фиксированным name.

Исходный текст

SKILL.md · MIT
---
name: rspack-split-chunks
description: Diagnose or tune Rspack splitChunks for duplicate modules, route over-fetching, cache groups, caching, or oversized chunks.
---

# Rspack SplitChunks optimization

Use this skill when the task is to recommend, review, or debug `optimization.splitChunks`. If you are using ESM library, it's not the same algorithm of this skill.

## Default stance

- Distinguish repo defaults from recommended production baselines.
- Rspack's built-in default is `chunks: "async"`, but for most production web apps the best starting point is:

```js
optimization: {
  splitChunks: {
    chunks: "all",
  },
}
```

- Keep the default cache groups unless there is a concrete reason to replace them.
- Treat `name` as a graph-shaping option, not a cosmetic naming option.
- Do not use `splitChunks` to reason about JavaScript execution order or tree shaking. For JS, chunk loading/execution order is preserved by the runtime dependency graph, and tree shaking is decided elsewhere.

Read [`references/repo-behavior.md`](references/repo-behavior.md) when you need the source-backed rationale.

## What to optimize for

First identify which problem the user actually has:

- duplicated modules across entry or async boundaries
- a route fetching a large shared chunk with mostly unused modules
- too many tiny chunks
- a vendor/common chunk that changes too often and hurts caching
- an oversized async or initial chunk that should be subdivided
- confusion about whether `splitChunks` affects runtime execution order

Do not optimize all of these at once. Pick the primary goal and keep the rest as constraints.

## Workflow

### 1. Start from the safest production baseline

Unless the user already has a measured problem that requires custom grouping, prefer:

```js
optimization: {
  splitChunks: {
    chunks: "all",
  },
}
```

Why:

- it lets splitChunks dedupe modules across both initial and async chunks
- it still only loads chunks reachable from the current entry/runtime
- it usually avoids loading unnecessary modules better than hand-written global vendor buckets

If the existing config disables `default` or `defaultVendors`, assume that is suspicious until proven necessary.

### 2. Audit the config for high-risk knobs

Check these first:

- fixed `name`
- `cacheGroups.*.name`
- `enforce: true`
- disabled `default` / `defaultVendors`
- broad `test: /node_modules/` rules combined with a single global `name`
- `usedExports: false`
- very small `minSize`
- `maxSize` combined with manual global names

### 3. Interpret `name` correctly

Use this rule:

- No `name`: splitChunks can keep different chunk combinations separate.
- Same `name`: matching modules are merged into the same named split chunk candidate.

That means a fixed `name: "vendors"` or `name: "common"` is often the real reason a page starts fetching modules from unrelated dependency chains.

Prefer these alternatives before adding `name`:

- keep `name` unset
- use `idHint` if the goal is filename identity, not grouping identity
- narrow the `test` so the cache group is smaller
- split one broad cache group into several focused cache groups
- rely on `maxSize` to subdivide a big chunk instead of forcing a global name

Use a fixed `name` only when the user explicitly wants one shared asset across multiple entries/routes and accepts the extra coupling.

### 4. Preserve the built-in cache groups by default

Rspack's built-in production-oriented behavior depends heavily on these two groups:

- `default`: extracts modules shared by at least 2 chunks and reuses existing chunks
- `defaultVendors`: extracts `node_modules` modules and reuses existing chunks

These defaults are usually the best balance between dedupe and "only fetch what this page needs".

If you customize `cacheGroups`, do not casually replace these with one manually named vendor bucket.

### 5. Use `chunks: "all"` without fear of breaking execution order

When a module group is split out, Rspack connects the new chunk back to the original chunk groups. That preserves JavaScript loading semantics.

So:

- `splitChunks` changes chunk topology
- the runtime still guarantees dependency loading/execution order
- if execution order appears broken, look for other causes first
- this statement is about JavaScript, not CSS order

### 6. Use `maxSize` as a refinement tool

Use `maxSize`, `maxAsyncSize`, or `maxInitialSize` when the problem is "this shared chunk is too large", not when the problem is "I need a stable vendor chunk name".

Important behavior:

- `maxSize` runs after a chunk already exists
- the split is deterministic
- modules are grouped by path-derived keys and split near low-similarity boundaries
- similar file paths tend to stay together

This is usually safer than forcing one giant named vendor chunk, because it keeps chunk graph semantics while subdividing hot spots.

### 7. Use `usedExports` deliberately

If the user has multiple runtimes/entries and wants leaner shared chunks per runtime, prefer keeping `usedExports` enabled.

If they set `usedExports: false`, expect broader sharing and potentially larger common chunks.

This is still not tree shaking. It only changes how splitChunks groups modules across runtimes.

### 8. Treat `enforce: true` as an escape hatch

`enforce: true` bypasses several normal guardrails. Use it only when the user intentionally wants a split regardless of `minSize`, `minChunks`, and request limits.

If a config looks aggressive and hard to explain, check `enforce` before changing anything else.

## Recommendations by goal

### Better default production chunking

Recommend:

```js
optimization: {
  splitChunks: {
    chunks: "all",
  },
}
```

Avoid:

- disabling `default`
- disabling `defaultVendors`
- adding `name` before measuring a real problem

### Avoid fetching non-essential modules

Recommend:

- remove fixed `name`
- keep cache groups narrow
- keep `chunks: "all"` if dedupe across initial chunks is still desired
- inspect which routes now depend on a shared chunk after each change

Avoid:

```js
cacheGroups: {
  vendors: {
    test: /[\\/]node_modules[\\/]/,
    chunks: "all",
    name: "vendors",
    enforce: true
  }
}
```

That pattern often creates one over-shared chunk that many pages must fetch.

### Improve caching without over-merging

Recommend:

- keep `name` unset
- use `idHint`
- keep `chunkIds: "deterministic"` or other stable id strategies elsewhere in the config
- split broad groups into smaller focused groups only when the package boundaries are stable and important

Use a fixed `name` only if the user explicitly prefers cache reuse over route isolation.

### Split a large shared chunk

Recommend:

```js
optimization: {
  splitChunks: {
    chunks: "all",
    maxSize: 200000,
  },
}
```

Then tune:

- `maxAsyncSize` when async chunks are the pain point
- `maxInitialSize` when first-load pressure matters more
- `hidePathInfo` if generated part names should not leak path structure

### Keep an intentionally shared chunk

Recommend a named chunk only when the user says something like:

- "all pages should share one React vendor asset"
- "I want one framework chunk for cache reuse across routes"

Even then, call out the tradeoff explicitly:

- better cache hit rate
- more coupling between routes
- a page may fetch modules it does not execute immediately

## Review checklist

When reviewing a user's config, explicitly answer:

1. Is the goal dedupe, cache stability, request count, or route isolation?
2. Is `chunks: "all"` a better baseline than the current config?
3. Did `name` accidentally turn multiple candidates into one forced shared chunk?
4. Were `default` or `defaultVendors` disabled without a strong reason?
5. Would `idHint` satisfy the naming goal without changing grouping?
6. Is `maxSize` a better fit than a broad manual vendor/common bucket?
7. Does the result still keep each page fetching only reachable chunks?

## Minimal stats setup

When the task includes diagnosis, ask for or generate stats that expose chunk relations:

```js
stats: {
  chunks: true,
  chunkRelations: true,
  chunkOrigins: true,
  entrypoints: true,
  modules: false
}
```

Then compare:

- which entrypoints reference which shared chunks
- whether a change added a new dependency edge from an entry to a broad shared chunk
- whether a large shared chunk exists only because of a fixed `name`

## FAQ

### Why do I still see duplicate modules?

Common reasons:

- the shared candidate is too small, so extracting it would not satisfy `minSize`
- the candidate does not satisfy `minSizeReduction`
- it does not satisfy `minChunks`
- request-budget limits reject the split
- `chunks` / `test` / `cacheGroups` do not actually select the same chunk combination

If the duplicate module is tiny, do not assume this is a bug. Rspack may intentionally keep it in place because splitting it out would create a worse chunk.

### Does splitChunks affect JS execution order?

No.

- `splitChunks` only changes chunk boundaries and dependency edges
- JS loading and execution order are runtime concerns
- if a JS ordering bug appears, investigate runtime/bootstrap, side effects, or app code first

### Does splitChunks affect tree shaking?

No.

- tree shaking is controlled by module-graph analysis such as `sideEffects`, `usedExports`, and dead-code elimination
- `splitChunks` runs later and only reorganizes already-selected modules into chunks
- `splitChunks.usedExports` is only a grouping hint for runtime-specific chunk combinations; it is not tree shaking itself

### Can splitChunks affect CSS order?

Yes, potentially.

- this caveat applies to CSS order, not JS execution order
- extracted CSS flows such as `mini-css-extract-plugin` or `experiments.css` can observe changed final CSS order after splitChunks rewrites chunk groups
- if CSS order is critical, be careful when splitting order-sensitive styles into separate chunks

See [web-infra-dev discussion #12](https://github.com/orgs/web-infra-dev/discussions/12).

## Quick conclusions to reuse

- "Keep `chunks: \"all\"`, keep the default cache groups, and remove `name` unless you intentionally want forced sharing."
- "`name` is not just a filename hint in Rspack splitChunks; it changes grouping behavior."
- "`splitChunks` does not control JS execution order or tree shaking; it only changes chunk topology."
- "`splitChunks` can affect CSS order in extracted-CSS scenarios, so treat CSS as a separate caveat."
- "`maxSize` is the safer tool when the problem is one chunk being too large."

© rstackjs · MIT · rstackjs/agent-skills

Похожие скиллы

Все скиллы по теме «Фронтенд и UI» →
rsdoctor web-infra-dev MCP-сервер rsdoctor отдаёт агенту данные сборки Rspack: размеры ассетов, зависимости модулей, время компиляции и диагностику дублей пакетов. CX Codex +1 ★ 1 152звёзд репо tree-shaking patterns.dev Скилл tree-shaking для Claude Code, Codex, Cursor, Copilot, Gemini CLI и OpenCode учит вырезать неиспользуемый код из JavaScript-бандлов. Срабатывает при сборке проекта, когда импортированные модули тянут экспорты, которые не используются. CX Codex +1 1 600установок webpack-bundler Mindrally Скилл webpack-bundler для Claude Code помогает настраивать Webpack, разбирать загрузчики и плагины и оптимизировать сборку JavaScript-проекта. Активируется при работе с конфигурацией и процессом разработки. CX Codex +1 848установок turbopack официальный Vercel Labs Скилл помогает настроить сборщик Turbopack в Next.js 16, перенести правила с Webpack и решить ошибки сборки. CX Codex GP ChatGPT +1 5установок rspeedy-bundle-size lynx-community Скилл rspeedy-bundle-size разбирает, из чего складывается вес .lynx.bundle в rspeedy/ReactLynx, и подсказывает, за какой рычаг тянуть первым. CX Codex +1 491установок millers-law Owl-Listener Скилл millers-law для Claude Code группирует поля, пункты меню и шаги по смысловым блокам. Он включается при проектировании структуры интерфейса. CX Codex +1 2 100установок

Из того же набора21

Весь набор →
migrate-to-rsbuild Скилл migrate-to-rsbuild переводит фронтенд-проекты с webpack, Vite, Create React App и Vue CLI на сборщик Rsbuild. Он пошагово заменяет конфигурацию и проверяет запуск перед удалением старых пакетов. CX Codex +1 342установок rspack-tracing Скилл rspack-tracing для Claude Code и других IDE захватывает и анализирует traces сборок Rspack, чтобы найти медленные фазы компилятора, плагины и лоадеры. Помогает диагностировать крахи и узкие места прямо в процессе разработки. CX Codex +1 291установок rspack-debugging Скилл rspack-debugging для Claude Code снимает через LLDB состояние краша нативного Rspack и собирает бэктрейсы при segfault, дедлоке или зависшей сборке. CX Codex +1 282установок storybook-rsbuild Скилл storybook-rsbuild настраивает Storybook на Rsbuild или переносит существующий проект с webpack и Vite. Он также учитывает интеграции с Rslib, Modern.js и Rspack. CX Codex +1 212установок migrate-to-rslib Скилл migrate-to-rslib переводит сборку библиотек с tsc или tsup на Rslib с проверкой билда и сохранением исходного кода. CX Codex +1 201установок rspress-v2-upgrade Скилл rspress-v2-upgrade автоматизирует переход Rspress-проекта с версии 1 на версию 2. Читает конфиг, обновляет зависимости, меняет импорты и валидирует результат по официальному гайду. CX Codex +1 150установок rstest-debugging Скилл rstest-debugging помогает найти причину проблем Rstest со стартом, сборкой, рантаймом, логами, памятью и производительностью по трассам и сопоставимым замерам. CX Codex +1 133установок rslib-modern-package Скилл rslib-modern-package для Claude Code помогает создавать и проверять JS/TS-библиотеки на Rslib: от публичного API и зависимостей до готовности к публикации. Создаёт новые библиотеки и модернизирует существующие. CX Codex +1 125установок

Спонсоры проекта

Компании, которые помогают держать аналитику открытой