PluginBench
Skill
Pass
Audit score 90

generating-lwc-components

forcedotcom/sf-skills

Lightning Web Components with PICKLES methodology, wire patterns, SLDS 2 styling, and Jest testing.

What is generating-lwc-components?

Generates Lightning Web Components (LWC) bundles with best practices for data access, accessibility, and performance. Use this skill when creating or editing LWC components, building wire service patterns, integrating Apex or GraphQL, styling with SLDS 2, or writing Jest unit tests.

  • Scaffold LWC component bundles with proper file structure (.js, .html, .css, .js-meta.xml)
  • Design data access patterns: LDS, Apex @AuraEnabled, GraphQL, Lightning Message Service, or external APIs
  • Build wire service, imperative Apex, and GraphQL integration patterns
  • Apply SLDS 2 styling, dark mode compliance, and accessibility (WCAG, ARIA, keyboard navigation)
  • Write Jest unit tests with async rendering helpers and component mocking
  • Validate performance, rerender safety, and event contracts

How to install generating-lwc-components

npx skills add https://github.com/forcedotcom/sf-skills --skill generating-lwc-components
Prerequisites
  • Active Salesforce org connection for local preview and data access
  • SF CLI installed for local dev server and component scaffolding
  • Node.js and npm for Jest test execution
Claude Code
Cursor
Windsurf
Cline

How to use generating-lwc-components

  1. 1.Gather component requirements: purpose, data source, target surface (App Builder, Flow, Experience Cloud)
  2. 2.Choose a data access pattern from the workflow table (LDS, Apex, GraphQL, LMS)
  3. 3.Use provided asset templates (basic-component, datatable, form, flow-screen, graphql, modal) as starting points
  4. 4.Implement component logic, template, and styling following PICKLES methodology
  5. 5.Validate accessibility, SLDS 2 compliance, and performance against the 165-point scoring rubric
  6. 6.Write Jest tests using the provided test template and async rendering helpers
  7. 7.Run local dev preview with hot reload to test changes before deployment

Use cases

Good for
  • Create a record detail component with LDS wire service and inline editing
  • Build a datatable with Apex-backed pagination and custom actions
  • Design a Flow screen component with input/output properties for declarative workflows
  • Implement Lightning Message Service (LMS) publisher/subscriber for cross-DOM communication
  • Write Jest tests for component logic, event handling, and async data flows
Who it's for
  • Salesforce developers building Lightning Web Components
  • Frontend engineers integrating Apex or GraphQL backends
  • QA engineers writing Jest unit tests for LWC
  • Accessibility specialists ensuring WCAG compliance in custom UI

generating-lwc-components FAQ

When should I use @wire vs. imperative Apex calls?

Use @wire for reactive, read-only use cases (getRecord, getList). Use imperative calls for explicit user actions, DML operations, and complex server queries that need caching control.

What is the PICKLES methodology?

PICKLES is a component design mindset: Prototype, Integrate data source, Compose boundaries, define interaction model, use platform Libraries, optimize Execution, enforce Security.

How do I preview LWC components locally without deploying?

Run the local dev server commands in scripts/local-dev-preview.sh. It provides hot reload for .js, .html, and .css files and requires an active org connection for data and Apex callouts.

Should I use custom CSS or SLDS 2 styling?

Prefer SLDS 2 base components and CSS hooks/variables over custom colors and controls. Avoid hardcoded colors to support dark mode and accessibility.

What should I do after finishing the LWC component?

Delegate Apex controller creation to generating-apex, Flow embedding to generating-flow, and metadata deployment to deploying-metadata. Report component(s) created, data pattern, files changed, quality notes, and next step.

Full instructions (SKILL.md)

Source of truth, from forcedotcom/sf-skills.


name: generating-lwc-components description: "Lightning Web Components with PICKLES methodology and 165-point scoring. Use this skill when the user creates or edits LWC components, builds wire service patterns, or writes Jest tests for LWC. TRIGGER when: user creates/edits LWC components, touches lwc/**/*.js, .html, .css, .js-meta.xml files, or asks about wire service, SLDS, or Jest LWC tests. DO NOT TRIGGER when: Apex classes (use generating-apex), Aura components, or Visualforce." metadata: version: "1.1"

generating-lwc-components: Lightning Web Components Development

Use this skill when the user needs Lightning Web Components: LWC bundles, wire patterns, Apex/GraphQL integration, SLDS 2 styling, accessibility, performance work, or Jest unit tests.

When This Skill Owns the Task

Use generating-lwc-components when the work involves:

  • lwc/**/*.js, .html, .css, .js-meta.xml
  • component scaffolding and bundle design
  • wire service, Apex integration, GraphQL integration
  • SLDS 2, dark mode, and accessibility work
  • Jest unit tests for LWC

Delegate elsewhere when the user is:

  • writing Apex controllers or business logic first → generating-apex
  • building Flow XML rather than an LWC screen component → generating-flow
  • deploying metadata → deploying-metadata

Required Context to Gather First

Ask for or infer:

  • component purpose and target surface
  • data source: LDS, Apex, GraphQL, LMS, or external system via Apex
  • whether the user needs tests
  • whether the component must run in Flow, App Builder, Experience Cloud, or dashboard contexts
  • accessibility and styling expectations

Recommended Workflow

1. Choose the right architecture

Use the PICKLES mindset:

  • prototype
  • integrate the right data source
  • compose component boundaries
  • define interaction model
  • use platform libraries
  • optimize execution
  • enforce security

2. Choose the right data access pattern

NeedDefault pattern
single-record UILDS / getRecord
simple CRUD formbase record form components
complex server queryApex @AuraEnabled(cacheable=true)
related graph dataGraphQL wire adapter
cross-DOM communicationLightning Message Service

3. Start from an asset when useful

Use provided assets for:

  • basic component bundles
  • datatables
  • modal patterns
  • Flow screen components
  • GraphQL components
  • LMS message channels
  • Jest tests
  • TypeScript-enabled components

4. Validate for frontend quality

Check:

  • accessibility
  • SLDS 2 / dark mode compliance
  • event contracts
  • performance / rerender safety
  • Jest coverage when required

5. Hand off supporting backend or deploy work

Use:

  • generating-apex for controllers / services
  • deploying-metadata for deployment
  • running-apex-tests only for Apex-side test loops, not Jest

High-Signal Rules

  • prefer platform base components over reinventing controls
  • use @wire for reactive read-only use cases; imperative calls for explicit actions and DML paths
  • do not introduce inaccessible custom UI
  • avoid hardcoded colors; use SLDS 2-compatible styling hooks / variables
  • avoid rerender loops in renderedCallback()
  • keep component communication patterns explicit and minimal

Output Format

When finishing, report in this order:

  1. Component(s) created or updated
  2. Data access pattern chosen
  3. Files changed
  4. Accessibility / styling / testing notes
  5. Next implementation or deploy step

Suggested shape:

LWC work: <summary>
Pattern: <wire / apex / graphql / lms / flow-screen>
Files: <paths>
Quality: <a11y, SLDS2, dark mode, Jest>
Next step: <deploy, add controller, or run tests>

Local Development Server

Preview LWC components locally with hot reload — no deployment needed. Run the commands in scripts/local-dev-preview.sh to start a local dev session for a component, app, or Experience Cloud site.

Local Dev commands install just-in-time on first run. They are long-running processes that open a browser with live preview. Changes to .js, .html, and .css files auto-reload instantly. Requires an active org connection for data and Apex callouts.


Cross-Skill Integration

NeedDelegate toReason
Apex controller or servicegenerating-apexbackend logic
embed in Flow screensgenerating-flowdeclarative orchestration
deploy component bundledeploying-metadataorg rollout
create supporting metadata (message channels, objects)deploying-metadatametadata deployment

Reference File Index

Start here

Accessibility / performance / state

Integration / advanced features

Asset templates

Scripts


Score Guide

ScoreMeaning
150+production-ready LWC bundle
125–149strong component with minor polish left
100–124functional but review recommended
< 100needs significant improvement