webiny-skill-generator

Generate, update, and maintain abstraction catalogs from the Webiny platform's public API. Use this skill whenever you need to: scan the `webiny` package to discover exported EventHandlers and UseCases, regenerate catalog JSON files after a platform release, check which abstractions are available, or add support for a new abstraction type.

7,955 stars

bywebiny

View on GitHub Installation ↓

Best use case

webiny-skill-generator is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Teams using webiny-skill-generator should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

You only need a quick one-off answer and do not need a reusable workflow.
You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/skills-generator/SKILL.md --create-dirs "https://raw.githubusercontent.com/webiny/webiny-js/main/.claude/skills/skills-generator/SKILL.md"

Manual Installation

Download SKILL.md from GitHub
Place it in .claude/skills/skills-generator/SKILL.md inside your project
Restart your AI agent — it will auto-discover the skill

How webiny-skill-generator Compares

Feature / Agent	webiny-skill-generator	Standard Approach
Platform Support	Not specified	Limited / Varies
Context Awareness	High	Baseline
Installation Complexity	Unknown	N/A

Frequently Asked Questions

What does this skill do?

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

Related Guides

AI Agents for Marketing

Discover AI agents for marketing workflows, from SEO and content production to campaign research, outreach, and analytics.

AI Agents for Startups

Explore AI agent skills for startup validation, product research, growth experiments, documentation, and fast execution with small teams.

AI Agents for Coding

Browse AI agent skills for coding, debugging, testing, refactoring, code review, and developer workflows across Claude, Cursor, and Codex.

SKILL.md Source

# Webiny Skill Generator

Generates per-category **catalog JSON files** from the `webiny` npm package's public API. Each catalog lists all UseCase and EventHandler abstractions in a category with their resolved source file paths. LLMs read source files on demand for exact, up-to-date types — no enrichment phase needed.

## How It Works

```bash
yarn generate-skills
```

The script:

1. **Discovers** all EventHandler and UseCase exports from `packages/webiny`
2. **Resolves** the actual source file path for each export via ts-morph
3. **Writes** one catalog JSON per category to `skills/catalogs/`

That's it. No skeletons, no enrichment, no templates.

## Output

```
skills/
├── catalogs/
│   ├── api-cms.json           # 82 entries
│   ├── api-security.json      # 37 entries
│   ├── api-website-builder.json
│   ├── api-tenancy.json
│   ├── api-file-manager.json
│   ├── api-aco.json
│   ├── api-scheduler.json
│   └── api-system.json
└── patterns/
    ├── use-case.md            # Generic UseCase pattern doc
    └── event-handler.md       # Generic EventHandler pattern doc
```

Each catalog entry looks like:

```json
{
  "className": "CreateTenantUseCase",
  "importPath": "webiny/api/tenancy",
  "type": "use-case",
  "typeLabel": "UseCase",
  "humanName": "Create Tenant",
  "entity": "Tenant",
  "operation": "create",
  "sourceFilePath": "packages/api-core/src/features/tenancy/CreateTenant/index.ts",
  "description": "Programmatically create tenant."
}
```

## How LLMs Use Catalogs

1. **Find the right abstraction**: Read the catalog JSON for the relevant category
2. **Read the pattern doc**: `skills/patterns/use-case.md` or `skills/patterns/event-handler.md`
3. **Resolve types on demand**: Read the `sourceFilePath` from the catalog entry to get exact interfaces, payloads, and error types
4. **Generate code**: Use the pattern + resolved types to write the extension

This ensures types are always current — no stale snapshots.

## CLI Options

```bash
# Full regeneration
yarn generate-skills

# Verbose output
yarn generate-skills --verbose

# Check discovered exports without writing files
yarn generate-skills --check

# Only process a specific category
yarn generate-skills --category api/cms

# Only process a specific plugin type
yarn generate-skills --plugin event-handler
```

## Release Workflow

1. Run `yarn generate-skills` after a platform release
2. Commit the updated catalog files
3. That's it — no enrichment step needed

## Adding a New Abstraction Type

To support a new pattern (e.g., classes ending in `Middleware`):

1. Create a new plugin in `scripts/generateSkills/src/plugins/` implementing the `AbstractionPlugin` interface
2. Register it in `scripts/generateSkills/src/plugins/index.ts`
3. Run the pipeline — new entries appear in catalogs automatically

Related Skills

webiny-v5-to-v6-migration

7955

from webiny/webiny-js

Migration patterns for converting v5 Webiny code to v6 architecture. Use this skill when migrating existing v5 plugins to v6 features, converting context plugins to DI services, adapting v5 event subscriptions to v6 EventHandlers, or understanding how v5 patterns translate to v6. Targeted at AI agents performing migrations.

webiny-api-permissions

7955

from webiny/webiny-js

Schema-based permission system for API features. Use this skill when implementing authorization in use cases, defining permission schemas with createPermissionSchema, creating injectable permissions via createPermissionsAbstraction/createPermissionsFeature, checking read/write/delete/publish permissions, handling own-record scoping, or testing permission scenarios. Covers the full pattern from schema definition to use case integration to test matrices.

webiny-admin-permissions

7955

from webiny/webiny-js

Admin-side permission UI registration and DI-backed permission checking. Use this skill when adding permission controls to the admin UI — schema-based auto-generated forms, injectable permissions via createPermissionsAbstraction/ createPermissionsFeature, typed hooks (createUsePermissions), the HasPermission component (createHasPermission), and the Security.Permissions component props. Covers both simple apps and complex multi-entity permission schemas.

webiny-sdk

7955

from webiny/webiny-js

Using @webiny/sdk to read and write CMS data from external applications. Use this skill when the developer is building a Next.js, Vue, Node.js, or any external app that needs to fetch or write content to Webiny, set up the SDK, use the Result pattern, list/get/create/update/publish entries, filter and sort queries, use TypeScript generics for type safety, work with the File Manager, or create API keys programmatically. Covers read vs preview mode, the `values` wrapper requirement, correct method names, and the `fields` required parameter.

webiny-project-structure

7955

from webiny/webiny-js

Webiny project layout, webiny.config.tsx anatomy, and extension registration. Use this skill when the developer asks about folder structure, where custom code goes, how to register extensions, what webiny.config.tsx does, or how the project is organized. Also use when they need to understand the relationship between extensions/, webiny.config.tsx, and the different extension types (Api, Admin, Infra, CLI).

webiny-local-development

7955

from webiny/webiny-js

Deploying, developing locally, managing environments, and debugging Webiny projects. Use this skill when the developer asks about deployment commands (deploy, destroy, info), local development with watch mode (API or Admin), the Local Lambda Development system, environment management (long-lived vs short-lived, production vs dev modes), build parameters, state files, debugging API/Admin/Infrastructure errors, or the redeploy-after-watch requirement.

webiny-infrastructure-extensions

7955

from webiny/webiny-js

Modifying AWS infrastructure using Pulumi handlers and declarative Infra components. Use this skill when the developer wants to customize AWS infrastructure, add Pulumi handlers, configure OpenSearch, VPC, resource tags, regions, custom domains, blue-green deployments, environment-conditional config, or manage production vs development infrastructure modes. Covers CorePulumi.Interface, all <Infra.*> declarative components, and <Infra.Env.Is>.