Generating Lightning App

platform-lightning-app-coordinate

Build complete Salesforce Lightning Experience applications from natural language descriptions. Use this skill when a user requests a "complete app", "Lightning app", "business solution", "management system", or describes a scenario requiring multiple interconnected Salesforce components (objects, fields, pages, tabs, security). Orchestrates all required metadata types in proper dependency order to produce a deployable application.

forcedotcom/sf-skills·5.5Kinstalls1.1Kstars

SKILL.md

Full skill instructions

Generating Lightning App

Overview

Build a complete, deployable Salesforce Lightning Experience application from a natural language description by defining a Lightning Custom Application and orchestrating its dependent metadata types in correct dependency order. Invoke specialized metadata skills when available; generate metadata directly when no skill exists.

When to Use This Skill

Use when:

User requests a "Lightning app", or "end-to-end solution"
User says "build an app", "create an application", "build a [type] app" (project management, tracking, etc.)
The work produces a custom app (CustomApplication) plus supporting metadata, not a lone object, page, or tab in isolation

Examples that should trigger this skill:

"Build a project management lightning app with Tasks, Resources, and Supplies objects"
"Create a LEX app to track vehicles with Lightning pages and permission sets"
"I need a Space Station management system with multiple objects and relationships"
"Build an employee onboarding lightning app with custom Lightning Record Pages"

Do NOT use when:

Creating a single metadata component (use specific metadata skill instead)
Troubleshooting or debugging existing metadata
Building Salesforce Classic apps (not Lightning Experience)
User asks for just one object, or just one page, or just one permission set (without others)
User only needs to create or configure an app container (grouping existing tabs) without other metadata; use platform-custom-application-generate instead

Metadata Type Registry

This table shows which metadata types are commonly needed for Lightning Experience apps, their skill availability, and API context requirement.

Metadata Type	Skill Name	API Context	Usage Rule
Custom Object	`platform-custom-object-generate`	`salesforce-api-context`	MUST load skill AND call API context
Custom Field	`platform-custom-field-generate`	`salesforce-api-context`	MUST load skill AND call API context
Custom Tab	`platform-custom-tab-generate`	`salesforce-api-context`	MUST load skill AND call API context
FlexiPage	`platform-flexipage-generate`	`salesforce-api-context`	MUST load skill AND call API context
Custom Application	`platform-custom-application-generate`	`salesforce-api-context`	MUST load skill AND call API context
List View	`platform-list-view-generate`	`salesforce-api-context`	MUST load skill AND call API context (if requested)
Validation Rule	`platform-validation-rule-generate`	`salesforce-api-context`	MUST load skill AND call API context (if requested)
Flow	`automation-flow-generate`	`metadata-experts` pipeline	MUST load skill AND run pipeline. Exempt from `salesforce-api-context`.
Permission Set	`platform-permission-set-generate`	`salesforce-api-context`	MUST load skill AND call API context

Usage Rules

SKILL RULE: When a skill exists for a metadata type, you MUST load that skill. Do NOT generate metadata directly without loading the skill first.

API CONTEXT RULE: For every metadata type (except Flow), you MUST call salesforce-api-context tools before generating. Do NOT generate metadata without calling API context first. The skill provides structure and rules; API context confirms what is valid for the current API version. Both are essential.

FALLBACK RULE: When no skill exists for a metadata type you need, generate the metadata directly using your knowledge of Salesforce Metadata API and best practices. API context is still required.

RATIONALE: Skills contain validated patterns and constraints. API context provides version-specific accuracy. Together they prevent deployment failures.

Dependency Graph & Build Order

Phase 1: Data Model (Foundation)

Custom Objects (no dependencies)
    ↓
Custom Fields (depends on: Objects exist)
    ↓
Relationships (depends on: Both parent and child objects + fields exist)

Metadata types in this phase:

platform-custom-object-generate - once, with all objects
platform-custom-field-generate - once, with all fields (including Master-Detail, Lookup, Roll-up Summary)

Phase 2: Business Logic (Optional - only if requested)

Validation Rules (depends on: Fields exist)
    ↓
Flows (depends on: Objects, Fields exist)

Metadata types in this phase (only if user requested):

platform-validation-rule-generate - once, if validation requirements mentioned
automation-flow-generate - once, if automation/workflow requirements mentioned

Phase 3: User Interface

List Views (depends on: Objects, Fields exist)
    ↓
Custom Tabs (depends on: Objects exist)
    ↓
FlexiPages (depends on: Objects, Tabs exist)

Metadata types in this phase:

platform-list-view-generate - once, for filtered record views (if requested)
platform-custom-tab-generate - once, with all object tabs
platform-flexipage-generate - once, with all record/home/app pages

Phase 4: Application Assembly

Custom Application (depends on: Tabs exist)

Metadata types in this phase:

platform-custom-application-generate - once, to create the Lightning App container

Phase 5: Security & Access

Permission Sets (depends on: Objects, Fields, Tabs, App exist)

Metadata types in this phase:

platform-permission-set-generate - once, with all permission sets and access to:
- Objects (Read, Create, Edit, Delete)
- Fields (Read, Edit)
- Tabs (Visible)
- Custom Application (Visible)

Execution Workflow

STEP 1: Requirements Analysis & Planning

Actions:

Parse user's natural language request
Extract business entities (become Custom Objects)
Extract attributes/properties (become Custom Fields)
Identify relationships (Master-Detail, Lookup)
Detect validation requirements (become Validation Rules)
Detect automation requirements (become Flows)
Identify user personas (inform Permission Sets)

Output: Build Plan

Generate a structured plan listing:

Lightning App Build Plan: [App Name]

DATA MODEL:
- Custom Objects: [list with object names]
- Custom Fields: [list grouped by object]
- Relationships: [list M-D and Lookup relationships]

BUSINESS LOGIC (if applicable):
- Validation Rules: [list with object and rule name]
- Flows: [list with flow name and type]

USER INTERFACE:
- List Views (if requested): [list with object and view name]
- Custom Tabs: [list with object]
- FlexiPages: [list with page name and type]
- Custom Application: [app name]

SECURITY:
- Permission Sets: [list with purpose]

PER-TYPE EXECUTION (skill + API context for each):
- CustomObject: load platform-custom-object-generate + call salesforce-api-context
- CustomField: load platform-custom-field-generate + call salesforce-api-context
- ValidationRule: load platform-validation-rule-generate + call salesforce-api-context (if requested)
- Flow: load automation-flow-generate + run metadata-experts pipeline (if requested)
- ListView: load platform-list-view-generate + call salesforce-api-context (if requested)
- CustomTab: load platform-custom-tab-generate + call salesforce-api-context
- FlexiPage: load platform-flexipage-generate + call salesforce-api-context
- CustomApplication: load platform-custom-application-generate + call salesforce-api-context
- PermissionSet: load platform-permission-set-generate + call salesforce-api-context

STATUS LINES TO EMIT BEFORE FILE WRITES:
- `type=<Type> skill=complete mcp=complete|unavailable mcp_tools=<tool-list|none>`
- Flow exception: `type=Flow skill=complete pipeline=complete`

DEPENDENCY ORDER:
1. Phase 1: Data Model (Objects -> Fields)
2. Phase 2: Business Logic (Validation Rules -> Flows)
3. Phase 3: User Interface (List Views -> Tabs -> Pages)
4. Phase 4: App Assembly (Application)
5. Phase 5: Security (Permission Sets)

STEP 2: Per-Type Execution

Execute these four steps for each metadata type, one type at a time. Complete all four steps for the current type before moving to the next type. Do NOT skip any step.

Step	What to do	Why
① Load skill	Search for and read the per-type SKILL.md	Gives you the XML structure, required elements, naming rules, and validation constraints
② Call API context	Call `salesforce-api-context` tools for this metadata type using one or more of: `get_metadata_type_sections`, `get_metadata_type_context`, `get_metadata_type_fields`, `get_metadata_type_fields_properties`, `search_metadata_types`	Gives you the current valid values — allowed enum values, required vs. optional fields, child types for this API version. The skill provides structure; API context provides version-specific accuracy.
③ Record status	Emit: `type=<Type> skill=complete mcp=complete\|unavailable mcp_tools=<tool-list\|none>`	Confirms both steps were attempted before any files are written and records which API context tools were used
④ Generate files	Generate all files for this type, then checkpoint	Only after ①②③ are done. Verify, then move to the next type.

Do NOT combine ① and ② into a single action or skip ② after completing ①. They are separate steps that serve different purposes. After loading the skill you may feel ready to generate — stop and do ② first.

If salesforce-api-context is unavailable after a real attempt, record mcp=unavailable and generate using skill knowledge alone. Not attempting ② at all is a bug.

1. Custom Objects

① Load skill: Read platform-custom-object-generate SKILL.md
② API context: Call salesforce-api-context for CustomObject
③ Status: type=CustomObject skill=complete mcp=complete|unavailable mcp_tools=<tool-list|none>
④ Generate + Checkpoint: Generate all Custom Object files, then proceed to #2

2. Custom Fields

① Load skill: Read platform-custom-field-generate SKILL.md
② API context: Call salesforce-api-context for CustomField
③ Status: type=CustomField skill=complete mcp=complete|unavailable mcp_tools=<tool-list|none>
④ Generate + Checkpoint: Generate all Custom Field files, then proceed to #3

3. Validation Rules (only if requested)

① Load skill: Read platform-validation-rule-generate SKILL.md
② API context: Call salesforce-api-context for ValidationRule
③ Status: type=ValidationRule skill=complete mcp=complete|unavailable mcp_tools=<tool-list|none>
④ Generate + Checkpoint: Generate all Validation Rule files, then proceed to #4

4. Flows (only if requested)

① Load skill: Read automation-flow-generate SKILL.md
② Pipeline: Run metadata-experts/execute_metadata_action 3-step pipeline (exempt from salesforce-api-context)
③ Status: type=Flow skill=complete pipeline=complete
④ Generate + Checkpoint: Generate all Flow files via the pipeline, then proceed to #5

5. List Views (only if requested)

① Load skill: Read platform-list-view-generate SKILL.md
② API context: Call salesforce-api-context for ListView
③ Status: type=ListView skill=complete mcp=complete|unavailable mcp_tools=<tool-list|none>
④ Generate + Checkpoint: Generate all List View files, then proceed to #6

6. Custom Tabs

① Load skill: Read platform-custom-tab-generate SKILL.md
② API context: Call salesforce-api-context for CustomTab
③ Status: type=CustomTab skill=complete mcp=complete|unavailable mcp_tools=<tool-list|none>
④ Generate + Checkpoint: Generate all Custom Tab files, then proceed to #7

7. FlexiPages

① Load skill: Read platform-flexipage-generate SKILL.md
② API context: Call salesforce-api-context for FlexiPage
③ Status: type=FlexiPage skill=complete mcp=complete|unavailable mcp_tools=<tool-list|none>
④ Generate + Checkpoint: Generate all FlexiPage files, then proceed to #8

8. Custom Application

① Load skill: Read platform-custom-application-generate SKILL.md
② API context: Call salesforce-api-context for CustomApplication
③ Status: type=CustomApplication skill=complete mcp=complete|unavailable mcp_tools=<tool-list|none>
④ Generate + Checkpoint: Generate the Custom Application file, then proceed to #9

9. Permission Sets

① Load skill: Read platform-permission-set-generate SKILL.md
② API context: Call salesforce-api-context for PermissionSet
③ Status: type=PermissionSet skill=complete mcp=complete|unavailable mcp_tools=<tool-list|none>
④ Generate + Checkpoint: Generate all Permission Set files — all types complete

STEP 3: Final Artifact Assembly

After all phases complete, consolidate outputs into deployment-ready structure.

Output

The completed build produces:

Salesforce DX Project Directory containing all generated metadata
- Organized by standard SFDX structure: force-app/main/default/

Metadata Files - One file per component, organized by type:

force-app/main/default/
├── objects/              # Custom Objects (.object-meta.xml)
├── fields/               # Custom Fields (.field-meta.xml)
├── tabs/                 # Custom Tabs (.tab-meta.xml)
├── flexipages/           # Lightning Pages (.flexipage-meta.xml)
├── applications/         # Custom Applications (.app-meta.xml)
├── permissionsets/       # Permission Sets (.permissionset-meta.xml)
├── flows/                # Flows (.flow-meta.xml) - if applicable
└── objects/.../validationRules/  # Validation Rules (.validationRule-meta.xml) - if applicable

Deployment Manifest (package.xml)
- Lists all components with proper API version
- Organized by metadata type in dependency order
- Ready for Salesforce CLI deployment or Metadata API deployment
Build Summary Report - A markdown file listing:
- Every component created
- Component type and API name
- File path location
- Dependency relationships
- Any warnings or recommendations

Example Summary Structure:

Lightning App Build Complete: Project Management App

METADATA GENERATED:
1 Custom Objects
   - Project__c -> force-app/main/default/objects/Project__c/Project__c.object-meta.xml
   - Task__c -> force-app/main/default/objects/Task__c/Task__c.object-meta.xml
   - Resource__c -> force-app/main/default/objects/Resource__c/Resource__c.object-meta.xml

2 Custom Fields
   - Project__c.Name -> force-app/main/default/objects/Project__c/fields/Name.field-meta.xml
   - Project__c.Status__c -> force-app/main/default/objects/Project__c/fields/Status__c.field-meta.xml
   [... etc ...]

3 Custom Tabs
   - Project__c -> force-app/main/default/tabs/Project__c.tab-meta.xml
   [... etc ...]

4 Lightning Record Pages
   - Project_Record_Page -> force-app/main/default/flexipages/Project_Record_Page.flexipage-meta.xml
   [... etc ...]

5 Custom Application
   - Project_Management -> force-app/main/default/applications/Project_Management.app-meta.xml

6 Permission Sets
   - Project_Manager -> force-app/main/default/permissionsets/Project_Manager.permissionset-meta.xml
   - Project_User -> force-app/main/default/permissionsets/Project_User.permissionset-meta.xml

WARNINGS: None

Validation

Before presenting the completed build to the user, verify cross-component integrity:

Object-Tab Coverage: Every Custom Object has at least one Custom Tab
Relationship Integrity: Every Custom Object referenced in a relationship (parent or child) exists in the build
Field References in Pages: Every field referenced in a FlexiPage exists on the corresponding object
Tab References in App: Every tab referenced in the Custom Application was successfully created
Permission Set Completeness: Permission Sets grant access to all generated objects, fields, tabs, and the application
No Orphaned Components: No tabs without objects, no pages without corresponding tabs, no app without tabs
Deployment Manifest Completeness: package.xml includes all generated components in proper dependency order

Validation Failure Handling (Category 2):

If validation fails, include failed checks in the Build Summary Report under a VALIDATION WARNINGS section
These are post-generation issues — do NOT block delivery of the build, but clearly communicate what needs manual review or correction
Provide specific remediation steps for each failed validation check

Note: Individual component validations (reserved words, name lengths, field types, etc.) are handled by specialized metadata skills and do not need to be re-validated here.

Error Handling

Category 1: Stop and Ask User

Stop execution and ask for clarification if:

User request is too vague to extract any objects or fields
Conflicting requirements detected (e.g., "make it private" + "everyone should see it")
Invalid Salesforce naming detected (reserved words like Order, Group)

Category 2: Post-Generation Warnings (Log Warning, Continue)

Log warning and continue if:

Cross-component validation check fails (e.g., field referenced in FlexiPage doesn't exist on object)
Optional component generation fails (e.g., List View generation has minor issues)
Validation Rule or Flow has minor output issues

Warning Pattern:

Warning: [Component Type] generation encountered issue
    Component: [Name]
    Issue: [Description]
    Impact: [What won't work]
    Recommendation: [How to fix manually]
    Continuing with remaining components...

Best Practices

1. Always Follow Dependency Order

Never invoke skills out of sequence. Fields need objects, pages need tabs, apps need tabs.

2. Use Skills When Available

Don't reinvent the wheel. Specialized skills have field-specific validation that prevents deployment errors.

3. Generate Thoughtful Defaults

When user doesn't specify details:

Use Text name fields for human entities
Use AutoNumber for transactions
Enable Search and Reports for user-facing objects
Set sharingModel based on relationships

4. Validate Before Building

Check for:

Reserved words in API names
Relationship limits (max 2 M-D per object)
Name length limits
Duplicate names

Install skill

Copy and run in your terminal

npx -y skills add https://github.com/forcedotcom/sf-skills --skill platform-lightning-app-coordinate

View on GitHub

platform-lightning-app-coordinate

platform-apex-generate
Primary Apex authoring skill for class generation, refactoring, and review. ALWAYS ACTIVATE when the user mentions Apex, .cls, triggers, or asks to create/refactor a class (service, selector, domain, batch, queueable, schedulable, invocable, DTO, utility, interface, abstract, exception, REST resource). Use this skill for requests involving SObject CRUD, mapping collections, fetching related records, scheduled jobs, batch jobs, trigger design, @AuraEnabled controllers, @RestResource endpoints, custom REST APIs, or code review of existing Apex.
6.7K installs
platform-apex-test-generate
Generate and validate Apex test classes with TestDataFactory patterns, bulk testing (251+ records), mocking strategies, assertion best practices, and disciplined test-fix loops. Use this skill when creating new Apex test classes, improving test coverage, debugging and fixing failing Apex tests, running test execution and coverage analysis, or implementing testing patterns for triggers, services, controllers, batch jobs, queueables, and integrations. Triggers on *Test.cls, *_Test.cls files, sf apex run test workflows, coverage reports, test-fix loops. Do NOT trigger for production Apex code (use platform-apex-generate) or Jest/LWC tests.
6.6K installs
platform-apex-test-run
Apex test execution, coverage analysis, and test-fix loops with 120-point scoring. Use when the user needs to run Apex tests, check code coverage, fix failing tests, or work with *Test.cls / *_Test.cls files. TRIGGER when: user runs Apex tests, checks code coverage, fixes failing tests, or touches *Test.cls / *_Test.cls files. DO NOT TRIGGER when: writing Apex production code (use platform-apex-generate), Agentforce agent testing (use agentforce-test), or Jest/LWC tests (use experience-lwc-generate).
6.5K installs
platform-docs-get
Official Salesforce documentation retrieval skill. Use when you need authoritative Salesforce docs from developer.salesforce.com, help.salesforce.com, architect.salesforce.com, admin.salesforce.com, or lightningdesignsystem.com, especially when pages are JS-heavy, shell-rendered, or hard to extract with naive fetching. Use to ground answers in official Salesforce sources instead of third-party blogs or summaries. TRIGGER when: user asks for official Salesforce documentation, Apex or API reference, LWC docs, Agentforce docs, setup or help articles, or any doc from a Salesforce-owned domain. DO NOT TRIGGER when: user is asking for a code change, deployment task, or anything not requiring documentation retrieval — use the appropriate sf-* skill instead.
6.4K installs

More skills from forcedotcom

forcedotcom/sf-skills

platform-apex-logs-debug

Salesforce debug log analysis and troubleshooting with 100-point scoring. TRIGGER when: user analyzes debug logs, hits governor limits, reads stack traces, or touches .log files from Salesforce orgs. DO NOT TRIGGER when: running Apex tests (use platform-apex-test-run), generating or fixing Apex code (use platform-apex-generate), or Agentforce session tracing (use agentforce-observe).

1.1K 6.4K

View

forcedotcom/sf-skills

platform-soql-query

SOQL query generation, optimization, and analysis with 100-point scoring. Use this skill when the user needs SOQL/SOSL authoring or optimization: natural-language-to-query generation, relationship queries, aggregates, query-plan analysis, and performance or safety improvements for Salesforce queries. TRIGGER when: user writes, optimizes, or debugs SOQL/SOSL queries, touches .soql files, or asks about relationship queries, aggregates, or query performance. DO NOT TRIGGER when: bulk data operations (use platform-data-manage), Apex DML logic (use platform-apex-generate), or report/dashboard queries.

1.1K 6.3K

View

forcedotcom/sf-skills

platform-metadata-deploy

Salesforce DevOps automation using sf CLI v2. TRIGGER when: user deploys metadata, creates/manages scratch orgs or sandboxes, sets up CI/CD pipelines, or troubleshoots deployment errors with sf project deploy. DO NOT TRIGGER when: writing Apex code (use platform-apex-generate), building LWC components (use experience-lwc-generate), creating metadata definitions (use platform-custom-object-generate or platform-custom-field-generate), or querying org data (use platform-data-manage).

1.1K 6.3K

View

forcedotcom/sf-skills

platform-metadata-retrieve

ALWAYS USE THIS SKILL to retrieve metadata from an org to your local project using the sf project retrieve start command. Supports multiple retrieval modes: retrieve all remote changes, retrieve by source directory, retrieve by metadata type with wildcards, retrieve by manifest (package.xml), or retrieve by package name. Use when the user asks to retrieve, pull, sync, or download metadata, Apex classes, custom objects, or org changes. Supports source format (default) or metadata format (ZIP). DO NOT TRIGGER for deploying metadata (use platform-metadata-deploy skill), listing metadata, or generating package.xml. NEVER use MCP tools - always use this skill and the Bash tool with sf project retrieve start.

1.1K 6.3K

View

forcedotcom/sf-skills

platform-custom-field-generate

Use this skill when users need to create, generate, or validate Salesforce Custom Field metadata. Trigger when users mention custom fields, field types, Roll-up Summary fields, Master-Detail relationships, Lookup relationships, formula fields, picklists, dependent (controlling) picklists, referencing a value set from a field, or scoping/limiting picklist values for a specific record type. Also use when users encounter field deployment errors, especially around Roll-up Summary format, Master-Detail constraints, formula issues, or a record type that won't deploy without a business process. Use this skill for custom field metadata work, field generation, and field troubleshooting. DO NOT TRIGGER for creating or customizing the value set itself — defining a new GlobalValueSet, or modifying a StandardValueSet catalog like Industry or Lead Source — use platform-value-set-generate instead; this skill covers the field that references a value set, not the value set definition.

1.1K 6.2K

View

forcedotcom/sf-skills

platform-permission-set-generate

Generates correct, deployable Salesforce permission set metadata (PermissionSet XML) with object, field, user, and app permissions. Use this skill when creating or editing permission set metadata, object permissions, field-level security (FLS), tab visibility, or deploying permission sets.

1.1K 6.1K

View

forcedotcom/sf-skills

dx-code-analyzer-run

Run Salesforce Code Analyzer to scan code for security, performance, best practice, and code style violations. Supports all engines (PMD, ESLint, CPD, RetireJS, Flow, SFGE, ApexGuru), targets (files, folders, git diff), categories, and severities. Also handles post-scan exploration: filtering results by engine/severity/category/file, and explaining what rules mean. TRIGGER when: user says 'scan my code', 'check security issues', 'run PMD/ESLint', 'find duplicates', 'analyze Flows', 'check vulnerable libraries', 'AppExchange review', 'lint my LWC', 'static analysis', 'code quality', 'show security violations', 'what is this rule', 'explain ApexCRUDViolation', 'filter results', or mentions engines/file types (.cls, .trigger, .js, .flow-meta.xml). Use this skill for scanning, exploring results, and listing rules. DO NOT TRIGGER when: user asks only about installation/configuration (use dx-code-analyzer-configure), or wants to create a custom rule (use dx-code-analyzer-custom-rule-create).

1.1K 6.1K

View

forcedotcom/sf-skills

automation-flow-generate

Generate Salesforce Flows using the MCP tool execute_metadata_action. Use when the user asks to create, build, or generate a flow — including Screen, Autolaunched, Record-Triggered (before/after-save), Scheduled. Also trigger for flow-like requests such as "when a record is created", "trigger daily at", "send an email when", "update the field when", "automate", "workflow", or "flow XML/metadata". This is the only skill for Salesforce Flow generation.

1.1K 6K

View

forcedotcom/sf-skills

platform-custom-object-generate

Use this skill when users need to create, generate, or validate Salesforce Custom Object metadata. Trigger when users mention custom objects, creating objects, object metadata, .object files, sharing models, name fields, or validation rules on objects. Also use when users say things like "create a custom object", "generate object metadata", "set up an object for...", or when they're troubleshooting object deployment errors especially around sharing models and Master-Detail relationships. Always use this skill for any custom object metadata work, including enriching and keeping the object's description current whenever its fields or validation rules change. Do NOT use this skill for non-Custom-Object metadata (Apex, Flows, LWC, Permission Sets, Custom Metadata Types) or for standard Salesforce objects.

1.1K 6K

View

forcedotcom/sf-skills

platform-data-manage

Salesforce data operations with 130-point scoring. Use this skill to create, update, delete, bulk import/export, generate test data, and clean up org records using sf CLI and anonymous Apex. TRIGGER when: user creates test data, performs bulk import/export, uses sf data CLI commands, needs data factory patterns for Apex tests, or needs to seed/clean records in a Salesforce org. DO NOT TRIGGER when: SOQL query writing only (use platform-soql-query), Apex test execution (use platform-apex-test-run), or metadata deployment (use platform-metadata-deploy).

1.1K 5.9K

View

forcedotcom/sf-skills

experience-lwc-generate

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 platform-apex-generate), Aura components, or Visualforce.

1.1K 5.9K

View

forcedotcom/sf-skills

design-systems-slds-apply

Apply SLDS-compliant UI using the correct blueprints, styling hooks, utility classes, and icons. Use when building any UI that needs SLDS, choosing between Lightning Base Components and SLDS Blueprints, applying styling hooks for theming, using utility classes for layout and spacing, or selecting icons. Triggers include "build a modal", "create a form", "data table", "SLDS styling", "style with hooks", "add an icon".

1.1K 5.8K

View