Agent skill

Igniteui Wc Optimize Bundle Size

by IgniteUI in IgniteUI/igniteui-webcomponents

Reduce application bundle size with Ignite UI Web Components by registering only needed components via named imports from the package root with defineComponents instead of defineAllComponents…

MITAuto-check passedFrontend & Design

Install Igniteui Wc Optimize Bundle Size

skills CLI
$ npx skills add IgniteUI/igniteui-webcomponents --skill igniteui-wc-optimize-bundle-size -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install IgniteUI/igniteui-webcomponents igniteui-wc-optimize-bundle-size --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/IgniteUI/igniteui-webcomponents.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/igniteui-wc-optimize-bundle-size .claude/skills/igniteui-wc-optimize-bundle-size && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
igniteui-wc-optimize-bundle-size
GitHub stars
170
Token cost
~3.6k tokens
SKILL.md length
848 words
Files
1
Skills in repo
13
Repo updated
First seen
Licence
MIT

At a glance

Reduce application bundle size with Ignite UI Web Components by registering only needed components via named imports from the package root with defineComponents instead of defineAllComponents…

  • Works in 3 steps: Find What Components You're Actually Using → Compare with Your Imports → Remove Unused Imports
  • Tasks that involve Web performance
  • SKILL.md covers Example Usage, Related Skills, When to Use and Key Principles, plus 10 more sections
  • Calls npm

What it does

Igniteui Wc Optimize Bundle Size is an agent skill from IgniteUI/igniteui-webcomponents. Reduce application bundle size with Ignite UI Web Components by registering only needed components via named imports from the package root with defineComponents instead of defineAllComponents, lazy-loading heavy components, and verifying tree-shaking with bundle analysis. WHEN TO USE: the user reports a large bundle or slow load, asks how to import components individually, wants to lazy-load grids, charts, or dock manager, or needs to audit Ignite UI imports in Vite/webpack/Rollup builds. WHEN NOT TO USE: initial…

Its SKILL.md is about 3.6k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Frontend & Design, covering Web performance. It works with Vite, webpack and React. The repository describes itself as: Ignite UI for Web Components is a complete library of UI components, giving you the ability to build modern web applications using encapsulation and the concept of reusable… The licence is MIT.

When your agent uses it

  • Tasks that involve Web performance

Example prompts

  • “/igniteui-wc-optimize-bundle-size”

Requirements

  • Node.js

Workflow steps

3 steps, taken from the step headings in SKILL.md.

  1. Find What Components You're Actually Using
  2. Compare with Your Imports
  3. Remove Unused Imports

What it can do on your machine

Read from SKILL.md and the folder at commit a6f3e2c. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • npm

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • npmjs.com
    • github.com
    • webpack.js.org
    • vitejs.dev
    • web.dev
    • bundlephobia.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Igniteui Wc Optimize Bundle Size loads about 3.6k tokens when it runs. Until then it costs about 204 tokens; SKILL.md has 848 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~204
When it runs · the whole SKILL.md, loaded when a task matches
~3.6k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from IgniteUI/igniteui-webcomponents at commit a6f3e2c, republished under its MIT licence (© IgniteUI). 848 words, ~3,554 tokens.

Download SKILL.mdSave it as .claude/skills/igniteui-wc-optimize-bundle-size/SKILL.md (or your agent's skills folder).
name
igniteui-wc-optimize-bundle-size
description
Reduce application bundle size with Ignite UI Web Components by registering only needed components via named imports from the package root with defineComponents instead of defineAllComponents, lazy-loading heavy components, and verifying tree-shaking with bundle analysis. WHEN TO USE: the user reports a large bundle or slow load, asks how to import components individually, wants to lazy-load grids, charts, or dock manager, or needs to audit Ignite UI imports in Vite/webpack/Rollup builds. WHEN NOT TO USE: initial package installation or framework wiring (use integrate-with-framework), choosing components (use choose-components), theming (use customize-component-theme), or general performance issues unrelated to bundle size such as runtime rendering or data virtualization.
license
MIT
user-invocable
true

Optimize Bundle Size

This skill helps users minimize their application's bundle size when using Ignite UI Web Components by importing only the components they need and following best practices for tree-shaking.

Example Usage

  • "My bundle size is too large"
  • "How do I reduce the size of igniteui-webcomponents?"
  • "Import only the components I need"
  • "Tree-shake unused components"
  • "Optimize imports for production"

When to Use

  • User's bundle size is too large
  • User wants to optimize for production
  • User is importing more components than needed
  • User asks about tree-shaking or optimization
  • User wants to improve load times

Key Principles

  1. Import only what you use - Don't use defineAllComponents()
  2. Use named imports - Enable tree-shaking
  3. Analyze your bundle - Identify what's being included
  4. Lazy load when possible - Load components on demand

Import Strategies

❌ Bad: Import Everything
typescript
// DON'T DO THIS - imports ALL components (~500KB+)
import { defineAllComponents } from 'igniteui-webcomponents';

defineAllComponents();

Impact: Includes all 60+ components whether you use them or not.

✅ Good: Import Specific Components
typescript
// DO THIS - import only what you need
import {
  defineComponents,
  IgcButtonComponent,
  IgcInputComponent,
  IgcCardComponent
} from 'igniteui-webcomponents';

defineComponents(IgcButtonComponent, IgcInputComponent, IgcCardComponent);

Impact: Bundle includes only 3 components and their dependencies.

React Applications

If you're using React, consider using the igniteui-react package instead of igniteui-webcomponents. It provides the same components with React-friendly wrappers and typically results in better tree-shaking:

bash
npm install igniteui-react
tsx
import { IgrButton, IgrInput, IgrCard } from 'igniteui-react';

// No need to call defineComponents - components register automatically
function MyComponent() {
  return (
    <div>
      <IgrButton variant="contained">Click me</IgrButton>
      <IgrInput label="Name" />
      <IgrCard>Content</IgrCard>
    </div>
  );
}

Benefits for bundle size:

  • Automatic tree-shaking (only imported components are included)
  • No need for component registration overhead
  • Better integration with React build tools

For more details, see the igniteui-wc-integrate-with-framework skill.

Analyzing Your Bundle

Use a bundle analyzer to identify what's being included before and after optimization.

Vite projects — rollup-plugin-visualizer:

bash
npm install --save-dev rollup-plugin-visualizer

Add visualizer() to the Vite plugins array and run npm run build. The plugin opens a treemap in the browser.

Webpack projects — webpack-bundle-analyzer:

bash
npm install --save-dev webpack-bundle-analyzer

Add BundleAnalyzerPlugin to webpack.config.js plugins and run npm run build.

Framework-agnostic — source-map-explorer:

bash
npm install --save-dev source-map-explorer
# Then: source-map-explorer 'dist/**/*.js'

Audit Your Component Usage

1. Find What Components You're Actually Using

Search your codebase for component usage:

bash
# Search for component tags in templates
grep -r "igc-" src/ --include="*.html" --include="*.tsx" --include="*.vue"

# List unique components
grep -roh "igc-[a-z-]*" src/ | sort | uniq
2. Compare with Your Imports

Check what you're importing vs what you're using:

typescript
// Find in your code
import {
  defineComponents,
  IgcButtonComponent,
  IgcInputComponent,
  IgcCardComponent,
  IgcSelectComponent,  // ← Are you using this?
  IgcComboComponent,   // ← Are you using this?
} from 'igniteui-webcomponents';
3. Remove Unused Imports

Remove components you're not using:

typescript
// Before: 5 components imported
import {
  defineComponents,
  IgcButtonComponent,
  IgcInputComponent,
  IgcCardComponent,
  IgcSelectComponent,
  IgcComboComponent,
} from 'igniteui-webcomponents';

defineComponents(
  IgcButtonComponent,
  IgcInputComponent,
  IgcCardComponent,
  IgcSelectComponent,
  IgcComboComponent
);

// After: Only 3 components needed
import {
  defineComponents,
  IgcButtonComponent,
  IgcInputComponent,
  IgcCardComponent,
} from 'igniteui-webcomponents';

defineComponents(IgcButtonComponent, IgcInputComponent, IgcCardComponent);

Lazy Loading Components

Load components only when needed to reduce initial bundle size.

Vanilla JavaScript / TypeScript
typescript
// Load immediately (increases initial bundle)
import { defineComponents, IgcDialogComponent } from 'igniteui-webcomponents';
defineComponents(IgcDialogComponent);

// Lazy load (smaller initial bundle)
async function showDialog() {
  const { defineComponents, IgcDialogComponent } = await import('igniteui-webcomponents');
  defineComponents(IgcDialogComponent);

  const dialog = document.createElement('igc-dialog');
  // ... use dialog
}
React (using igniteui-react)
tsx
import React, { lazy, Suspense, useState } from 'react';

// Lazy load the dialog component
const IgrDialog = lazy(() =>
  import('igniteui-react').then(module => ({ default: module.IgrDialog }))
);

function MyComponent() {
  const [showDialog, setShowDialog] = useState(false);

  return (
    <>
      <button onClick={() => setShowDialog(true)}>Open Dialog</button>
      {showDialog && (
        <Suspense fallback={<div>Loading...</div>}>
          <IgrDialog open>
            <h2>Dialog Content</h2>
          </IgrDialog>
        </Suspense>
      )}
    </>
  );
}
React (using web components directly)
tsx
import React, { useState } from 'react';

// Lazy load component registration
const lazyLoadDialog = async () => {
  const { defineComponents, IgcDialogComponent } = await import('igniteui-webcomponents');
  defineComponents(IgcDialogComponent);
};

function MyComponent() {
  const [dialogReady, setDialogReady] = useState(false);

  const openDialog = async () => {
    if (!dialogReady) {
      await lazyLoadDialog();
      setDialogReady(true);
    }
    // Show dialog
  };

  return (
    <button onClick={openDialog}>Open Dialog</button>
  );
}
Vue 3
vue
<script setup lang="ts">
import { ref } from 'vue';

const dialogReady = ref(false);

async function openDialog() {
  if (!dialogReady.value) {
    const { defineComponents, IgcDialogComponent } = await import('igniteui-webcomponents');
    defineComponents(IgcDialogComponent);
    dialogReady.value = true;
  }
  // Show dialog
}
</script>

<template>
  <button @click="openDialog">Open Dialog</button>
  <igc-dialog v-if="dialogReady" open>
    <h2>Dialog Content</h2>
  </igc-dialog>
</template>
Angular
typescript
import { Component } from '@angular/core';

@Component({
  selector: 'app-my-component',
  template: `
    <button (click)="openDialog()">Open Dialog</button>
    <igc-dialog *ngIf="dialogReady" [open]="true">
      <h2>Dialog Content</h2>
    </igc-dialog>
  `
})
export class MyComponent {
  dialogReady = false;

  async openDialog() {
    if (!this.dialogReady) {
      const { defineComponents, IgcDialogComponent } = await import('igniteui-webcomponents');
      defineComponents(IgcDialogComponent);
      this.dialogReady = true;
    }
  }
}

Route-Based Code Splitting

Load Ignite UI components only for the routes that need them by placing defineComponents(...) calls inside the lazy-loaded route module for each framework.

React (using React.lazy)

Put component imports and defineComponents at the top of each page module. React's lazy() + Suspense handles the async split:

tsx
// pages/Dashboard.tsx
import { IgrCard, IgrButton } from 'igniteui-react';

function Dashboard() {
  return (
    <div>
      <IgrCard>
        <h2>Dashboard</h2>
        <p>Dashboard content here</p>
      </IgrCard>
    </div>
  );
}

Refer to your router's lazy-loading docs (React Router, TanStack Router, etc.) for how to split pages/Dashboard into its own chunk.

Vue 3

Use onMounted to register components only when the route mounts:

vue
<script setup lang="ts">
import { onMounted } from 'vue';

onMounted(async () => {
  // Load components only for this route
  const { defineComponents, IgcCardComponent } = await import('igniteui-webcomponents');
  defineComponents(IgcCardComponent);
});
</script>

Refer to Vue Router docs for the () => import('./views/Dashboard.vue') lazy-route syntax.

Angular

Place defineComponents(...) inside the route's module or component so it's included only in that lazy chunk. Refer to Angular Router docs for loadChildren / loadComponent lazy loading.

Build Configuration Optimizations

Ensure your build tool is running in production mode with minification enabled. For Vite, this is the default for vite build. For Webpack, set mode: 'production'.

To reduce chunk-size warnings from Ignite UI components, increase the chunkSizeWarningLimit in Vite or configure splitChunks in Webpack to place igniteui-* packages in a named vendor chunk. Consult your build tool's documentation for the exact configuration options.

Show full SKILL.md (320 more words)Show less

Size Comparison

Actual sizes depend heavily on which components you import (grid and chart components are significantly larger than UI components). Use your bundle analyzer to measure the real impact in your project rather than relying on generic estimates.

The key rule: importing a subset of components with defineComponents() instead of defineAllComponents() will reduce the bundle by the weight of every component you don't include, plus all of their exclusive dependencies.

Best Practices Checklist

  • Never use defineAllComponents() unless you truly need every component
  • Use defineComponents() with specific components you need
  • Audit your imports regularly - remove unused components
  • Lazy load rarely-used components (dialogs, modals, etc.)
  • Split by routes - load components only for active routes
  • Analyze your bundle - use bundle analyzer tools
  • Enable tree-shaking - use named imports, not side-effect imports
  • Minify in production - ensure build tool minification is enabled
  • Use compression - enable gzip/brotli on your server

Common Issues and Solutions

Issue: Bundle still large after following best practices

Investigate:

  1. Check if you're importing many components at once
  2. Verify tree-shaking is working (check build output)
  3. Look for duplicate dependencies
  4. Check if source maps are included in production
  5. For React, ensure you're using igniteui-react instead of igniteui-webcomponents

Solutions:

typescript
// Review your imports - are you using all of these?
import {
  defineComponents,
  IgcButtonComponent,
  IgcInputComponent,
  IgcSelectComponent,
  IgcComboComponent,
  IgcDatePickerComponent
} from 'igniteui-webcomponents';

// Consider lazy loading components you don't need immediately
async function loadDialog() {
  const { defineComponents, IgcDialogComponent } = await import('igniteui-webcomponents');
  defineComponents(IgcDialogComponent);
}
Issue: Components not working after optimizing imports

Cause: Forgot to import a component you're using

Solution:

typescript
// Error: <igc-button> not working
// You're using igc-button but didn't import it

import { defineComponents, IgcButtonComponent } from 'igniteui-webcomponents';
defineComponents(IgcButtonComponent); // Add this
Issue: TypeScript errors after changing imports

Solution: Update type imports:

typescript
// Import types separately if needed
import type { IgcButtonComponent } from 'igniteui-webcomponents';

Monitoring Bundle Size

For ongoing bundle size monitoring in CI, tools like bundlesize, size-limit, or the Bundlewatch GitHub Action can fail a pull request when the bundle exceeds a defined threshold. Configure a size limit appropriate for your project's component set after you've completed the import optimization.

Next Steps

  • Profile your application with Chrome DevTools Performance tab
  • Implement lazy loading for heavy components
  • Consider using CDN for static assets
  • Enable HTTP/2 for better resource loading
  • Check igniteui-wc-integrate-with-framework for proper setup

Additional Resources

© IgniteUI, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/igniteui-wc-optimize-bundle-size of IgniteUI/igniteui-webcomponents.

Open the folder on GitHubat commit a6f3e2c

Compare with similar skills

Igniteui Wc Optimize Bundle Size next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Igniteui Wc Optimize Bundle Size compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Igniteui Wc Optimize Bundle Size this skillIgniteUI/igniteui-webcomponents170—~3.6kAutomated safety check: PassMIT
Ssr Boost MigrateLomray-Software/vite-ssr-boost118—~2.3kAutomated safety check: PassMIT
React Best Practicesryokun6/ryos1.3k—~2kAutomated safety check: PassMIT
Sentry React SDKgetsentry/sentry-for-ai268—~4.8kAutomated safety check: PassApache-2.0
Frontend Engineer Workflownanocoai/nanoclaw31k—~1.5kAutomated safety check: PassMIT
Phy Bundle Size AuditLeoYeAI/openclaw-master-skills2.2k—~4.9kAutomated safety check: PassApache-2.0

Similar skills

  • Ssr Boost Migrate

    Lomray-Software/vite-ssr-boost

    Migrate an existing Vite and React Router SPA to vite-ssr-boost SSR in Data mode, preserving route objects and checking streaming, hydration, bundle size, and deployment readiness.

    118 GitHub stars~2.3k tokensUpdated 16 days ago
    Frontend & DesignAuto-check passed
  • React performance optimization guidelines from Vercel Engineering (vercel-labs/agent-skills).

    1.3k GitHub stars~2k tokensUpdated yesterday
    Frontend & DesignAuto-check passed
  • Sentry React SDK

    getsentry/sentry-for-ai

    Official

    Full Sentry SDK setup for React. An agent skill from getsentry/sentry-for-ai.

    268 GitHub stars~4.8k tokensUpdated yesterday
    Frontend & DesignAuto-check passed
  • Sets a build, test and verify routine for web projects: write typed, accessible code and never call work done until it is checked in a real browser with screenshots.

    31k GitHub stars~1.5k tokensUpdated 2 days ago
    Frontend & DesignAuto-check passed
  • Phy Bundle Size Audit

    LeoYeAI/openclaw-master-skills

    JavaScript bundle size auditor and budget enforcer. An agent skill from LeoYeAI/openclaw-master-skills.

    2.2k GitHub stars~4.9k tokensUpdated 2 mo ago
    Frontend & DesignAuto-check passed
  • Nextjs

    ericrisco/rsc-harness

    A skill your agent uses when building, reviewing, testing, securing, or optimizing a Next.js App Router app: Server vs Client boundaries, use server actions, route handlers, the v15 vs v16 use cache…

    167 GitHub stars~5.1k tokensUpdated yesterday
    Frontend & DesignAuto-check passed

More from IgniteUI/igniteui-webcomponents

All 13 skills in this repo
  • Igniteui Wc Customize Component Theme

    IgniteUI/igniteui-webcomponents

    Theme and style Ignite UI Web Components (and igniteui-react) apps using CSS custom properties, optional Sass, and the igniteui-theming MCP server.

    170 GitHub stars~4.3k tokensUpdated yesterday
    Auto-check passed
  • Igniteui Wc Generate From Image Design

    IgniteUI/igniteui-webcomponents

    Implement application views from design images (screenshots, mockups, wireframes) using Ignite UI Web Components, with the igniteui-cli and igniteui-theming MCP servers for component discovery…

    170 GitHub stars~4.6k tokensUpdated yesterday
    Auto-check passed
  • Igniteui Wc Integrate With Framework

    IgniteUI/igniteui-webcomponents

    Install and integrate Ignite UI Web Components packages into React, Angular, Vue 3, LitElement, or vanilla JS/HTML apps, detecting the framework and applying framework-specific setup (package…

    170 GitHub stars~1.4k tokensUpdated yesterday
    Auto-check passed
  • Add Component Property

    IgniteUI/igniteui-webcomponents

    Add a reactive property to an existing Lit web component with proper decorators, types, tests, specification updates, and documentation

    170 GitHub stars~1.9k tokensUpdated yesterday
    Auto-check passed
  • Create New Component

    IgniteUI/igniteui-webcomponents

    Create a new Lit web component following project conventions, including specification, component class, styles, tests, Storybook story, and exports

    170 GitHub stars~3k tokensUpdated yesterday
    Auto-check passed
  • Igniteui Wc Choose Components

    IgniteUI/igniteui-webcomponents

    Identify the right Ignite UI Web Components (igniteui-webcomponents, grids, charts, dock manager, React wrappers) for a UI requirement and point to official docs, examples, and API references.

    170 GitHub stars~4.6k tokensUpdated yesterday
    Auto-check passed

Questions about Igniteui Wc Optimize Bundle Size

What does Igniteui Wc Optimize Bundle Size do?

Reduce application bundle size with Ignite UI Web Components by registering only needed components via named imports from the package root with defineComponents instead of defineAllComponents…. Igniteui Wc Optimize Bundle Size is an agent skill from IgniteUI/igniteui-webcomponents. Reduce application bundle size with Ignite UI Web Components by registering only needed components via named imports from the package root with defineComponents instead of defineAllComponents, lazy-loading heavy components, and verifying tree-shaking with bundle analysis.

When should I use Igniteui Wc Optimize Bundle Size?

Igniteui Wc Optimize Bundle Size fits situations like: tasks that involve Web performance.

How do I install Igniteui Wc Optimize Bundle Size in Claude Code?

Run `npx skills add IgniteUI/igniteui-webcomponents --skill igniteui-wc-optimize-bundle-size -a claude-code`. Or copy the skill folder (skills/igniteui-wc-optimize-bundle-size in IgniteUI/igniteui-webcomponents) into .claude/skills/igniteui-wc-optimize-bundle-size in your project. Claude Code loads it when a task matches its description.

How do I install Igniteui Wc Optimize Bundle Size in Codex?

Run `npx skills add IgniteUI/igniteui-webcomponents --skill igniteui-wc-optimize-bundle-size -a codex`. Or copy the skill folder (skills/igniteui-wc-optimize-bundle-size in IgniteUI/igniteui-webcomponents) into .agents/skills/igniteui-wc-optimize-bundle-size in your project. Codex loads it when a task matches its description.

Can I use Igniteui Wc Optimize Bundle Size in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add IgniteUI/igniteui-webcomponents --skill igniteui-wc-optimize-bundle-size -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/igniteui-wc-optimize-bundle-size, .gemini/skills/igniteui-wc-optimize-bundle-size, .github/skills/igniteui-wc-optimize-bundle-size and .opencode/skills/igniteui-wc-optimize-bundle-size in your project.

What does Igniteui Wc Optimize Bundle Size need to run?

Going by SKILL.md and its folder, Igniteui Wc Optimize Bundle Size needs the command-line tools its instructions call (npm). Our summary lists: Node.js.

Does Igniteui Wc Optimize Bundle Size access the network?

SKILL.md names 6 domains. As links in the text: npmjs.com, github.com, webpack.js.org, vitejs.dev, web.dev and bundlephobia.com. This is read from the text; nothing was executed.

Is Igniteui Wc Optimize Bundle Size safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Igniteui Wc Optimize Bundle Size use?

Igniteui Wc Optimize Bundle Size is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Igniteui Wc Optimize Bundle Size use?

About 3.6k tokens (SKILL.md is roughly 14k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Igniteui Wc Optimize Bundle Size?

Skills that share tags, products or a category with Igniteui Wc Optimize Bundle Size: Ssr Boost Migrate (Lomray-Software/vite-ssr-boost, 118 stars), React Best Practices (ryokun6/ryos, 1.3k stars), Sentry React SDK (getsentry/sentry-for-ai, 268 stars) and Frontend Engineer Workflow (nanocoai/nanoclaw, 31k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Igniteui Wc Optimize Bundle Size?

IgniteUI (a GitHub organization) maintains it in IgniteUI/igniteui-webcomponents, which has 170 GitHub stars. The repository holds 13 skills in this directory. The repository was last updated on October 7, 2026.

Source: IgniteUI/igniteui-webcomponents on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.