forcedotcom/sf-skills
64 skills38.9k installs32.8k starsGitHub
Install
npx skills add https://github.com/forcedotcom/sf-skillsSkills in this repo
1Generating ApexGenerating Apex is the primary authoring skill for Salesforce solo builders shipping on Enterprise or Partner editions who need Apex that reads like an experienced admin team wrote it—not a one-off snippet from chat. Activate it whenever the user mentions Apex, .cls, triggers, SOQL-heavy services, scheduled or batch work, @AuraEnabled controllers, or @RestResource APIs. The skill forces a short intake (class type, objects, goal, naming, net-new vs refactor) before the agent writes code, which reduces rework on sharing keywords, access modifiers, and test deployment strategy. It distinguishes production patterns—selectors for queries, services for orchestration, domain for invariants—from trigger logic sprawl. For indie SaaS on Salesforce, this skill is how you keep integrations and custom REST surfaces consistent while you wear every hat. Use it during active feature build; pair with Salesforce testing and deployment skills when you move from local authoring to org validation.787installs2Generating Apex TestGenerating Apex Test is a Salesforce-focused agent skill that emits a structured Apex test class template around a class under test, aimed at solo builders and small teams who must hit coverage and bulk thresholds before promoting changes. When your agent adds or refactors Apex, this skill standardizes naming, @TestSetup data via TestDataFactory, and separate positive, bulk (251 records), negative, and exception scenarios so you do not ship hollow tests that fail review or org policy. The template uses modern Assert.areEqual patterns and clear Given/When/Then blocks you fill with real method invocations and queries. It lives in Ship because it is a pre-deploy safety step, not feature implementation. It assumes you already have Apex business logic and a data factory pattern in the repo; the deliverable is a private test class ready for Salesforce CLI or CI validation. Use it whenever coverage is thin, bulk paths are untested, or you want consistent test layout across a growing Apex codebase on Sales Cloud or custom org apps.776installs3Generating FlowGenerating-flow is the canonical Salesforce skill for turning plain-language automation requests into Flow metadata. Solo builders and small teams who already use Salesforce MCP (execute_metadata_action) install it when they need user-guided screen flows, silent autolaunched logic, record-triggered updates, or scheduled jobs—without writing Apex or clicking through Flow Builder for every variant. The skill encodes a strict three-step grounded pipeline so the agent fetches object context, picks elements, then emits XML that matches platform rules. It matters because ad-hoc Flow drafting often breaks on field references, trigger timing, or element limits; grounding metadata first reduces redeploy cycles. Use it during CRM-heavy SaaS build when onboarding, approvals, or notification chains must live in the customer’s org. It is not a general Apex or LWC skill—only Flow generation via the documented MCP actions.758installs4Generating Custom Objectgenerating-custom-object is a Salesforce-focused agent skill that produces CustomObject metadata XML aligned with Metadata API rules solo admins and indie SF consultants need when expanding data models. Invoke it when users ask to create a custom object, generate object metadata, configure sharing and security, or debug deployment errors—especially sharing models and Master-Detail relationships. The skill document is effectively a specification: overview of purpose, Tier 1 syntactic essentials the agent must verify, and explicit note that fullName lives in the filename (`Something__c.object-meta.xml`), not as a stray XML tag. It reduces failed deploys from missing required elements or invalid relationship combinations. Best for builders using Salesforce DX, unlocked packages, or org development who want the agent to double-check constraints before writing XML. Pair with your existing retrieve/deploy workflow rather than replacing source control review.757installs5Generating Custom FieldGenerating-custom-field is an agent skill for solo builders and small teams shipping on Salesforce who need reliable CustomField metadata instead of trial-and-error deploys. It walks creation and validation of custom fields on any object, with explicit guardrails for relationship fields, formulas, picklists, and roll-up summaries. The skill is written for moments when users mention custom fields, field types, roll-ups, master-detail, lookups, or field deployment failures—you should invoke it for any custom field metadata work, generation, or troubleshooting. By verifying mandatory XML constraints up front, it targets the field types that most often break Metadata API deployments. Use it during CRM schema design, migration prep, or when fixing failed field pushes from your repo or packaging pipeline.752installs6Querying Soqlquerying-soql packages Salesforce Object Query Language patterns for aggregates and grouped analytics that agents and developers paste into integrations, Apex-adjacent tooling, or CLI queries. Solo builders shipping on Salesforce or syncing CRM data into a sidecar SaaS need SOQL that respects governor limits and returns the right shaped results the first time. The skill emphasizes COUNT variants, financial rollups, MIN/MAX pairs, and GROUP BY slices such as calendar year on CloseDate—common in revenue dashboards and ops scripts. It is reference-oriented rather than a full data model tutorial, so you should already know which objects and fields you are querying. Pair it with your org’s schema docs when the agent drafts queries for production sync jobs or internal reporting endpoints.749installs7Generating Lwc ComponentsGenerating LWC Components is a Salesforce-focused agent skill that supplies an Apex controller template tailored for Lightning Web Components. Solo builders and small teams on Salesforce use it when they need wire-friendly cacheable reads, explicit mutation endpoints, and error handling that respects platform security rather than copying anonymous Apex snippets. The readme emphasizes patterns that pair with @wire in LWC—parameterized queries, optional parent and search filters, and enforcement via with sharing and WITH SECURITY_ENFORCED. It is a template skill for the Build phase when you are standing up account lists, record detail actions, or similar standard UI on Experience Cloud or internal orgs. Expect to rename LwcController to your domain controller and extend SOQL and DML for your objects; the value is consistent structure for agent-generated LWCs that pass review.745installs8Generating Permission SetGenerating-permission-set is an agent skill for solo builders and small teams shipping on Salesforce who need correct, deployable permission set metadata instead of guessing XML shape. It walks through defining core PermissionSet properties, adding object permissions for standard and custom objects, and continuing into field-level security and related permission constructs as described in the skill. Invoke it when you are creating or editing permission set metadata, granting object or field access, adjusting tab visibility, or preparing a deploy through the Metadata API. The output is administrator-friendly XML with descriptive API names such as Sales_Manager_Access and explicit CRUD flags, which reduces failed deploys and security mistakes from copy-pasted templates. It is a procedural generator focused on Salesforce governance, not a generic CRUD tutorial, and pairs naturally with other sf-skills for profiles, permission set groups, and broader org security design.742installs9Fetching Salesforce DocsFetching Salesforce Docs is an official-leaning, prompt-only skill from the Salesforce skills ecosystem that teaches agents how to pull trustworthy text from Salesforce’s public documentation sites. Solo builders shipping on Salesforce hit a familiar wall: Developer docs are JavaScript-heavy, Help articles return empty shells to naive fetchers, and the real specification often lives on a child URL linked from a broad guide index. This skill encodes when to descend into those child pages, which hosts are in scope, and how to discard weak captures that are not primary sources. An optional Python wrapper routes Help URLs into a dedicated extractor and supports pretty-printed output for grounding codegen or Agentforce configuration. Use it during integration builds, security reviews of Salesforce features, and early research when you must cite platform behavior correctly. It deliberately excludes local corpus indexing and PDF fallbacks so expectations stay clear: this is live official web retrieval discipline, not a bundled search appliance.736installs10Deploying Metadatadeploying-metadata is an agent skill for Salesforce solo builders and tiny implementation teams who move source-formatted metadata from a repo into scratch, sandbox, or production orgs with the Salesforce CLI. The captured guidance centers on packaging destructive changes: an XML manifest listing members and metadata type names to delete, paired with a primary package.xml deploy. It explains when to attach destructive manifests as pre-destructive or post-destructive phases so removals happen in the right order relative to additive deploys. Comment blocks illustrate common deletion targets including deprecated Apex, obsolete custom objects and fields, and retired Lightning or Aura components. Use this skill when you are planning a release that must remove components safely, not when you only need a quick retrieve or a single-file push without delete semantics. Operators should always validate against a non-production org first and keep backups or VCS history because deletes are hard to undo in target orgs.735installs11Running Apex TestsRunning Apex Tests is a Salesforce-focused agent skill that supplies a production-style Apex test class skeleton aligned with forcedotcom sf-skills conventions. Solo builders on the Salesforce platform use it when they need consistent @IsTest structure: centralized TestSetup using a Test Data Factory, clearly separated positive, negative, and bulk scenarios, and readable Given/When/Then blocks inside each method. The template calls out a 90%+ coverage goal, which matches common org requirements before promoting metadata. It does not run tests autonomously in your org—you still execute via Salesforce CLI or IDE—but it standardizes how agents author tests so reviews and CI expectations stay predictable. Best paired with an existing Apex class and factory utilities; swap placeholders for real object and method names, then fill assertions and edge cases the TODOs mark.734installs12Generating FlexipageGenerating Flexipage is an agent skill for solo builders and small teams customizing Salesforce Lightning without breaking metadata deployments. Salesforce Lightning pages—record, app, and home—are defined by FlexiPage XML where small structural mistakes cause opaque deploy failures. The skill enforces starting new pages from the CLI template bootstrap so regions, component references, and namespaces match what the platform expects, then guides modifications, component placement, and validation when users edit existing flexipage-meta.xml files. Invoke it whenever someone asks to create a Lightning page, add a component, customize a record page, or fix FlexiPage deploy errors, including casual mentions of “page” inside a Salesforce org. It pairs procedural knowledge with platform-specific rules so agents do not invent invalid XML. Intermediate complexity assumes familiarity with Salesforce DX, org auth, and Lightning Experience.733installs13Generating Custom TabGenerating Custom Tab is an agent skill for solo builders and small teams shipping on Salesforce who need correct CustomTab metadata without guessing XML fields. It triggers whenever work mentions tabs, navigation tabs, object tabs, web tabs, Visualforce tabs, Lightning component tabs, app page tabs, or adding navigation to custom objects and external content. The skill walks through the CustomTab specification: when customObject is true versus false, how motif icons should match semantic purpose, when label is required outside object tabs, and how url or page properties bind web or Visualforce destinations. That precision matters because bad tab metadata fails deployments and leaves users without navigation to custom objects or Lightning experiences. Use it during Build while modeling objects and app shells, and again in Ship when deployment errors reference tab visibility or missing pages. Outputs align with Salesforce DX metadata patterns your agent can drop into a project and push through your normal pipeline.731installs14Debugging Apex LogsDebugging Apex Logs is a Salesforce-focused agent skill for indie consultants and small teams maintaining Apex on customer orgs. Invoke it when work centers on debug log files: governor limit exceptions, cryptic stack traces, heap or CPU pressure, and slow SOQL patterns. The skill gathers org alias, failing flow, and log excerpts first, then applies a disciplined analysis model—including a 100-point scoring lens—so findings stay tied to log lines rather than guesswork. It deliberately does not run tests, author fixes, or parse Agentforce parquet telemetry; those paths point to sibling sf-skills. That separation keeps the agent in evidence mode until you know whether the bug is query shape, recursive triggers, bulkification, or async limits. For solo builders shipping Salesforce extensions or managed packages, this is the operate-phase triage step before you patch Apex or open a case with the customer.729installs15Generating Custom ApplicationGenerating Custom Application is a Salesforce agent skill for authoring CustomApplication (Lightning app) metadata. Solo builders and small teams on Salesforce use it when they need to package tabs, navigation, and branding into a coherent app for a workflow rather than leaving users in the default app switcher mess. The skill walks through when to pick Standard versus Console navigation, how apps organize features for roles, and how to resolve common deployment errors tied to custom applications. It fits builders who already know which tabs and objects belong together and want the agent to emit correct metadata instead of guessing XML shapes. It does not replace UI bundle hosting in the App Launcher—that is a different skill path. Expect intermediate familiarity with Salesforce org structure, profiles, and metadata deploy flows.729installs16Generating Custom Lightning Typegenerating-custom-lightning-type is a specialized agent skill for Salesforce builders who must define Custom Lightning Types so Einstein Agent actions speak in structured JSON instead of fragile free text. The readme positions CLT work as inherently complex and instructs agents to always invoke this skill when users mention CLT, Custom Lightning Types, `lightning__objectType`, or editor and renderer setups. It explains when to reference reusable nested CLTs versus inline standard Lightning types, and maps metadata expectations for deployment on the Lightning Platform. Solo admins and indie SI partners use it to avoid schema drift between agent actions, Flow, and Lightning UI. Trigger it during Build while wiring new agent tools, extending action contracts, or clearing CLT deployment failures. Outputs are schema-first artifacts and configuration notes your team can review before pushing to an org.729installs17Generating Lightning Appgenerating-lightning-app is an advanced Salesforce-focused agent skill for solo consultants and indie builders who need a whole Lightning application—not a lone custom object or page—from a plain-language brief. When someone asks for a complete app, Lightning app, business solution, management system, or a scenario with many linked components, the skill defines a Custom Application and drives the full metadata graph in dependency-safe order. It delegates to sibling sf-skills generators where they exist and falls back to direct metadata authoring when no specialized skill is available, covering objects, fields, tabs, FlexiPages, flows, validation rules, list views, permission sets, and related pieces named in the overview. The intended outcome is metadata you can deploy as a coherent Lightning Experience solution rather than a pile of unrelated XML fragments. Expect Salesforce platform literacy and comfort reviewing security and automation side effects before promoting to production orgs.724installs18Generating List ViewGenerating List View is an agent skill for Salesforce builders who need curated record tabs as deployable metadata instead of one-off UI tweaks. It walks through when to create list views, how filtered subsets and column layouts map to ListView XML, and where files belong in a Salesforce DX repo. Solo and indie teams shipping on Salesforce use it when prompts mention list views, “a view that shows…,” filter criteria, sharing visibility, or broken ListView deployments. The skill emphasizes standardized filters across roles and validates configuration before push. It pairs naturally with other sf-skills object metadata work and keeps list definitions version-controlled alongside the rest of force-app. Expect concrete XML structure guidance rather than generic CRM training.724installs19Generating Validation Rulegenerating-validation-rule is a Salesforce-focused agent skill from sf-skills for declarative ValidationRule metadata. Indie builders and small teams customizing CRM or internal apps on Salesforce need saves blocked when data violates business rules—required combinations, stage gates, pricing guards—without leaning solely on Apex triggers. The skill walks creation and modification of validation rules with formula expressions, API names, and meaningful error text, and it applies when users mention field validation, data quality rules, validation errors, or deployment failures tied to rules. It sits squarely in Build backend work for platform extensions and integrations. Complexity is intermediate because formula logic and metadata deployment edge cases require Salesforce familiarity. Pair it with org retrieval and deployment skills in the same repo when changing production metadata. It is not a substitute for Flow, Apex, or client-side validation when those layers are the right tool.721installs20Handling Sf DataHandling SF Data is a Salesforce-focused agent skill for solo builders and integrators who need tens of thousands of records in a org without tripping governor limits. It contrasts approaches: Salesforce CLI bulk CSV import as the default, Data Loader for very large volumes, and batch Apex to create records in governed chunks with stateful counters and configurable batch sizes. The included BulkAccountCreator-style pattern shows how to parameterize targets, industries, and naming prefixes while executing via Database.executeBatch. Typical uses include Bulk API 2.0 validation, dashboard and report testing at realistic scale, and pre-migration dry runs. Treat it as implementation guidance paired with your sandbox hygiene and security review, not a substitute for production data policies.711installs21Developing AgentforceDeveloping Agentforce is an agent skill for Salesforce builders who need a disciplined spec before touching Apex, Flows, or prompt templates. It centers on a repeatable Agent Spec layout: purpose and scope, behavioral intent, a subagent map diagram, mutable variables that gate routing, and actions with explicit backing logic targets and implementation status. Solo indie teams on Agentforce use it to avoid spaghetti topics—clarifying what the start agent must know, how subagents hand off, and which guardrails block off-topic or ambiguous requests. The skill fits the Build phase when you are designing customer-facing or internal agents on Salesforce, not when you are only doing CRM reporting or generic SEO. Pair it with your org’s security and compliance review because agent actions can invoke real business logic. Prism lists it under AI agent building for builders standardizing Agentforce architecture before implementation sprints.693installs22Generating Mermaid DiagramsGenerating Mermaid Diagrams is a template-oriented agent skill from Salesforce skills that standardizes how solo builders and small teams document Agentforce agents. When you are designing or reviewing a service agent, the skill supplies Mermaid flowchart patterns that separate the agent shell (description, topics, instructions) from each topic’s scope and actions, including visual cues for Apex and Flow integrations. It is aimed at anyone shipping customer-facing agents on Salesforce who needs shareable diagrams for stakeholders without maintaining a separate drawing tool. Use it while planning new topics, mapping escalation paths, or preparing architecture reviews before implementation hardens. The output is plain Mermaid text you can paste into docs, PRs, or wiki pages, which keeps agent design legible for both humans and coding agents extending the same repo.693installs23Switching OrgSwitching-org is a procedural Salesforce CLI skill for solo builders and small teams who juggle scratch orgs, sandboxes, and production aliases. When someone says switch org, change default org, set my org to, or use alias, the agent follows a fixed ritual: resolve orgIdentifier (or list orgs and ask), run sf config set target-org for local project scope by default, and only use --global when the user clearly wants system-wide default. Verification uses sf config get target-org --json with honest limits on what the JSON confirms. It requires Salesforce CLI sf v2+ and fits any moment you need CLI commands to hit the correct org before retrieve, deploy, or Apex tests—without guessing which authenticated identity is active.690installs24Building Sf Integrationsbuilding-sf-integrations is a forcedotcom agent skill focused on how solo builders and small teams implement dependable Salesforce integrations. The surfaced pattern centers on HTTP callouts that fail in the real world—timeouts, transient 5xx responses, and 429 rate limits—and gives Apex-ready structure instead of one-shot requests that break under load. You get a with-sharing CalloutRetryHandler that caps retries at three, applies exponential backoff timing constants, and only retries statuses the template explicitly marks as retryable. Because Apex cannot block with Thread.sleep, the skill calls out the platform-correct split: synchronous call paths can retry immediately in-process, while meaningful delay between attempts should be implemented through Queueable job chaining for async contexts. That guidance matters when an agent otherwise generates brittle callout code that either hammers an API or gives up after a single blip. Install it when you are in the Build phase connecting Salesforce to payment, enrichment, or internal REST services and want procedural knowledge your coding agent can follow without guessing Salesforce async limits.688installs25Generating Visual Diagramsgenerating-visual-diagrams is a Salesforce-focused agent skill that turns plain-language system lists into professional diagrams for integrations and data models. It supplies copy-ready prompt templates for integration architecture—systems, protocols, gateways, authentication, and retry queues—and worked examples that call Gemini’s image generation with pastel, enterprise-friendly styling. ERD guidance adopts the official architect.salesforce.com look by default, including entity boxes, relationship labels, and legend bars so solo builders documenting Org data models do not fight inconsistent visuals. Use it while you are building on Salesforce or composing docs for validators and launch reviewers who need a single glance at sync direction and object relationships. It is prompt-and-template driven, not a live Metadata API browser; you still own object names, compliance review, and final asset storage.687installs26Generating Ui Bundle MetadataGenerating UI bundle metadata in the Salesforce skills pack means authoring CSP Trusted Site records as deployable metadata so solo builders and small teams can whitelist HTTPS origins for images, fonts, connect-src APIs, and similar resources in Lightning and digital experiences. The skill walks through directory placement under force-app/main/default/cspTrustedSites, naming conventions that match fullName inside the XML, and the complete CspTrustedSite template including isApplicableToConnectSrc, isApplicableToFontSrc, and related directive toggles. It is aimed at indie Salesforce developers who hit CSP console errors after adding Unsplash, Open-Meteo, map tiles, or custom APIs. Use it while implementing integrations rather than guessing Setup UI clicks, so metadata stays version-controlled and repeatable across sandboxes and production.674installs27Configuring Connected Appsconfiguring-connected-apps is an agent skill for solo builders and small teams wiring external services into Salesforce orgs who need correct Connected App metadata instead of guessing OAuth XML. It supplies templated metadata documents for a basic API integration pattern—with callback URL, consumer secret requirements, Api and RefreshToken scopes, and enforced IP relaxation—and a Canvas-oriented variant for apps embedded in the Salesforce UI. Builders replace placeholders such as application label, administrator contact, description, and HTTPS callback URLs before deploying through Salesforce metadata APIs or packaging workflows. The skill is narrowly task-focused on Connected App configuration, making it ideal when your agent is scaffolding enterprise SaaS integrations during Build rather than running broad CRM consulting.673installs28Generating Ui Bundle FeaturesGenerating UI Bundle Features is an agent skill for Salesforce Lightning Web Components-style UI bundle projects. It activates when the repo contains uiBundles/*/src/ and the user asks for authentication or search—or when those two capabilities should not be rebuilt from scratch. The skill centers on the @salesforce/ui-bundle-features CLI: search existing src/ first (scoped away from node_modules and dist), list and describe available features, then install into the correct bundle directory with documented flags. Coverage is intentionally narrow—login, logout, protected routes, session handling, and global content search—while the broader catalog can include navigation, GraphQL, and Agentforce AI. Solo builders shipping on Salesforce’s UI bundle stack use it to stay consistent with platform-tested packages and avoid duplicate security-sensitive code paths.671installs29Deploying Ui Bundledeploying-ui-bundle is a Salesforce-focused agent skill that encodes the full UI bundle deployment ritual for SFDX projects. Solo builders and small teams shipping Experience Cloud or custom UI bundle apps should invoke it whenever the repo contains uiBundles source trees, *.uibundle-meta.xml, or sfdx-project.json and the task is authenticate, push, deploy, or post-deploy setup—not ad-hoc sf commands out of order. The skill stresses sequencing: connect the org first, install dependencies and produce dist/ when source changed, deploy via package.xml or project default, then run permission assignment, optional data import, GraphQL schema retrieval, and codegen that depend on the deployed org. That ordering prevents the common failure mode of fetching schema or generating clients against an org that never received the latest metadata. It pairs naturally with Salesforce build and codegen skills in the same repo and assumes comfort with Salesforce CLI workflows rather than generic web hosting deploys.667installs30Uplifting Components To Slds2Uplifting Components to SLDS 2 is a Salesforce-focused agent skill that walks solo builders and small teams through replacing hardcoded colors with the correct Lightning Design System 2 color hooks. It targets developers maintaining Lightning Web Components and Aura who hit linter ambiguity or inconsistent theming across light, dark, and branded experiences. The workflow insists you establish context from HTML or CMP markup, parent containers, ARIA, and interactive roles, then JavaScript dynamic class logic, before touching CSS—because the same class name can mean different semantic surfaces depending on structure. A clear selection priority favors semantic hooks for most decisions, with palette and system hooks reserved for edge cases. The guide covers hook families, variant numbering, and pairing rules so foreground text remains readable on chosen backgrounds. Use it during SLDS 2 uplift sprints, design-token audits, or when refactoring legacy styling without breaking accessibility or multi-theme support.662installs31Building Ui Bundle AppBuilding UI Bundle App is the Salesforce sf-skills orchestrator for solo builders and small teams who want a deployable React UI bundle application from a natural language prompt, including greenfield repos with only sfdx-project.json or uiBundles source trees. It must activate when you ask to build, create, or generate a React application, SPA, or frontend—even when styling detail is present—and when work spans more than one ui-bundle skill. Without this coordinator, metadata, features, data access, UI, Agentforce client work, file upload, site generation, and deployment can execute in the wrong order and leave the app inconsistent. The skill points you to generating-ui-bundle-metadata, generating-ui-bundle-features, using-ui-bundle-salesforce-data, building-ui-bundle-frontend, implementing-ui-bundle-agentforce-conversation-client, implementing-ui-bundle-file-upload, deploying-ui-bundle, generating-ui-bundle-site, and generating-ui-bundle-custom-app as the governed pipeline. Use generating-lightning-app for Lightning Experience with custom objects, and building-ui-bundle-frontend for surgical page edits on an existing bundle.661installs32Generating Ui Bundle SiteGenerating UI Bundle Site is a Salesforce-focused agent skill that scaffolds a complete CustomSite metadata document for a net-new Digital Experience React site. Solo builders and small teams shipping on Experience Cloud use it when they already chose a site name and need a safe, opinionated default rather than hand-rolling dozens of boolean and page-reference fields. The skill stresses that the template creates records only—it must not be used to mutate existing CustomSite definitions. Outputs land at sites/{siteName}.site-meta.xml with active site defaults, guest API restrictions, Aura request enablement, and standard community error routes. It fits the build phase when React UI bundles are being registered against org metadata before deploy or CI validation. Pair it with broader Salesforce DX skills for networks, digital experiences, and deployment; this skill narrows to the CustomSite shell so agents do not guess field names or omit mandatory portal settings.661installs33Testing Agentforcetesting-agentforce is a Salesforce-focused agent skill that ships a basic test specification template for Agentforce agents. It targets indie builders and small teams who already define agents in Agent Script and need repeatable topic-routing checks before org deploys. The skill explains that only a narrow YAML shape is parsed by @salesforce/agents—not generic AiEvaluationDefinition—and walks through placeholders for MasterLabel, subject binding, and testCases. You replace utterances and expectedTopic values to match your subagents, create the test via Salesforce CLI, then run with wait and JSON output for CI or manual review. Because routing mistakes silently send users to the wrong subagent, this skill matters as a lightweight harness when you lack a full evaluation platform. Use it when standing up a new agent or after changing topic boundaries, not when you only need unrelated Apex or LWC unit tests.661installs34Building Ui Bundle FrontendBuilding UI Bundle Frontend is an agent skill for the Build phase that encodes Salesforce UI bundle conventions so agents do not reinvent buttons or scatter styles across a React TypeScript app. It forces shared primitives from @/components/ui, utility-only Tailwind using semantic tokens like bg-background and text-muted-foreground, and cn() from @/lib/utils for composable class names. Solo builders shipping Salesforce-adjacent or sf-skills scaffolded apps use it whenever the agent might otherwise drop inline styles, CSS modules, or one-off HTML controls. The location table separates reusable primitives under src/components/ui, feature widgets under src/components/<feature>, and layout chrome under src/components/layout—keeping review and reuse predictable. Following the rules keeps agent-generated UI consistent with design-system expectations and reduces rework during ship-phase review.659installs35Observing AgentforceThe observing-agentforce skill is a query service that accesses Salesforce Data Cloud's Session Trace Data Model to retrieve session traces, conversations, messages, and LLM steps. Solo builders use it when troubleshooting agent behavior, analyzing conversation flows, or generating performance metrics for production Agentforce deployments. It matters because it provides the observability needed to understand agent interactions and optimize agent responses based on real usage data.650installs36Searching MediaSearching Media is a Salesforce-focused agent skill that owns the workflow for finding and retrieving existing visual assets—logos, icons, photos, banners, thumbnails, hero images, and backgrounds—from Salesforce CMS, Data 360, and related sources. Prism lists it for solo and small teams building on Salesforce who use Claude Code or similar agents with MCP. The skill is a hard gate: any request to search or get media must activate it before tools run, which prevents ad-hoc tool calls that skip source selection and scope checks. It explicitly excludes generating new AI images, editing assets, or generic brand search without media retrieval. Pair it with your org’s MCP server configuration and review Salesforce licensing and content usage rules for each asset you pull.645installs37Using Ui Bundle Salesforce Datausing-ui-bundle-salesforce-data helps solo builders and small SFDX teams stop guessing field names when wiring Lightning or custom UI bundles to Salesforce GraphQL. The skill ships a graphql-search workflow: from your project root (where schema.graphql lives), you pass entity names such as Account or Contact and receive structured sections for the type definition, filter and sort inputs, and create/update wrapper types. That maps directly to building typed queries, list views, and mutation forms without spelunking a huge schema by hand. It assumes a standard Salesforce DX layout and a generated or checked-in schema.graphql; it is not a substitute for org security review or full LWC implementation. For indie SaaS on Salesforce, it shortens the loop between schema exploration and correct GraphQL variables in UI bundles.645installs38Implementing Ui Bundle File UploadImplementing-ui-bundle-file-upload is a Salesforce-focused agent skill that walks you through adding file upload to React UI bundle apps using the platform’s supported programmatic APIs. It activates when your project layout includes uiBundles/*/src/ and the user asks for uploads, attachments, or drag-and-drop. The skill stresses a common pitfall: the package exports upload logic and progress callbacks, not ready-made React components, so you design the UX while the agent applies the correct ContentVersion integration pattern. Solo builders on Salesforce agent tooling avoid security and reliability gaps from bespoke XHR snippets. The workflow is intermediate—comfort with React UI bundles and npm installs is assumed—and it sits squarely in Build integrations. Following it keeps uploads consistent with Salesforce expectations and saves time versus debugging CORS, chunking, and metadata handling from scratch.641installs39Getting Datacloud SchemaGetting-datacloud-schema is an agent skill for Salesforce builders who need accurate Data Cloud object metadata without clicking through Setup. It wraps REST access patterns behind simple requests like listing every DLO in an org or dumping fields on Employee__dll or Individual__dlm. Solo and small teams use it when designing ETL mappings, validating agent tool inputs, or documenting customer data models before shipping integrations. The skill documents both conversational triggers and four direct script entry points (list/get for DLO and DMO). Prerequisites are standard: SF CLI installed and an authenticated org alias. It is narrowly focused on read-only schema retrieval—not deployment, ingestion, or transformation—so you pair it with separate Salesforce skills for writes and automation.631installs40Implementing Ui Bundle Agentforce Conversation ClientThis skill guides solo builders and small teams embedding Salesforce Agentforce Employee Agents in custom UI using the AgentforceConversationClient bundle. It walks through resolving the correct BotDefinition Id via SOQL against BotVersion (where Status lives), filtering to AgentforceEmployeeAgent, and validating IDs before render. It documents activation limits—agents must be activated in Agent Builder, not via API—and anti-patterns such as editing vendor implementation files instead of your consuming React components. For indie Salesforce ISVs or internal tool makers shipping agent-assisted consoles, it reduces broken embeds and support churn from wrong agent types or inactive versions. Invoke when you are wiring chat into an existing Lightning or React surface and need deterministic CLI queries plus constraint-aware edits.631installs41Developing Datacloud Code ExtensionDeveloping Data Cloud Code Extension is a quick-reference agent skill for solo Salesforce builders extending Data Cloud with script or function packages. It condenses the sf data-code-extension command surface you need when moving from an empty directory to a deployable payload: initialize a script or function project, scan the Python entrypoint for required permissions (including dry-run previews), execute locally against a named org, and deploy with the mandatory payload package directory. The README emphasizes practical flags—custom config paths, skipping requirements.txt on scan, and minimal deploy examples—so you spend less time reverse-engineering CLI help and more time validating transforms before they hit production orgs. It fits indie consultants and one-person RevOps engineers who own both the Python entrypoint and the org alias. It does not replace Data Cloud data model design or full CI pipelines; it accelerates the local iterate-and-deploy loop for code extensions.618installs42Retrieving Datacloudretrieving-datacloud is a Salesforce-focused agent skill that helps you pull the right Data Cloud constructs when building hybrid search over structured Data Model Objects. Solo builders on Salesforce stacks use it while wiring retrieval for Einstein or custom agents that must read from `__dlm` sources, chunk text fields, and expose vector indexes with consistent developerName conventions. The embedded reference walks through index labels, chunk and vector companion DMOs, HYBRID searchType, ranking hooks, and embedding configuration so generated metadata is less likely to fail org validation. It sits beside orchestrating-datacloud in the same family, with attribution centralized in CREDITS and UPSTREAM files rather than duplicated per skill. Expect intermediate complexity: you need familiarity with DMO naming, passage extraction settings, and embedding limits. Use during Build integrations before you ship retrieval-backed features to Ship security review.611installs43Connecting DatacloudConnecting-datacloud is a Salesforce-focused agent skill from the Data Cloud workflow family. It helps solo builders and small teams define Data Cloud connectors—especially Heroku Postgres ingress links and Ingest API endpoints—with structured JSON for credentials, JDBC URLs, databases, and ingest object schemas. Use it when you already know which source you need and want repeatable, copy-paste-safe connector payloads instead of guessing Tooling or setup UI fields. The skill sits alongside orchestrating-datacloud skills and points to shared maintenance notes so connector work stays aligned with upstream Salesforce guidance. It matters for indie SaaS and consulting stacks where CRM, marketing, and ops data must land in Data Cloud before segmentation or AI features. Expect integration literacy (secrets, host/port URLs) rather than one-click deploy; the agent fills templates and validates shape, not live org auth by itself.603installs44Preparing DatacloudPreparing-datacloud guides solo builders and small teams through the groundwork needed to land records in Salesforce Data Cloud via the Ingestion API—not the full orchestration of every pipeline, but the connect-and-prepare slice that must exist before send-data scripts work. The skill expects you to already plan connector names, object names such as Badge_Scan, and tenant-specific login URLs, then complete schema upsert with the Salesforce CLI and create data streams when the org requires UI steps. A minimal Python example illustrates sending records after those prerequisites, while related JSON connection and schema artifacts live under the connecting-datacloud examples path referenced in the readme. It pairs naturally with connecting and orchestrating datacloud skills in the same repository family credited to Gnanasekaran Thoppae. Use it when you are building event or badge-scan style ingestion into C360A tenants and need checklist-level env configuration without pasting live secrets into chat. Operate-phase monitoring comes later; this skill focuses on correct first-time integration setup.602installs45Orchestrating DatacloudOrchestrating-datacloud is the Salesforce Data Cloud product orchestrator in the sf-skills family. Solo builders and small teams use it when a task is bigger than one CLI command family: standing up a multi-step pipeline, debugging issues that cut across phases, or managing data spaces and data kits. The skill follows sf-skills house style while assuming the external `sf data360` plugin against a Data Cloud-enabled org. It owns workflow sequencing and phase ownership; phase-specific skills remain the right choice when work is isolated to Connect only, Prepare only, and similar boundaries. It deliberately excludes standard CRM SOQL, Apex generation, and STDM or session-tracing telemetry, which have dedicated skills. Expect MIT-licensed procedural guidance rather than vendored tooling, plus compatibility notes that you must install and trust the community CLI plugin yourself.601installs46Harmonizing DatacloudHarmonizing-datacloud is an agent skill for solo Salesforce admins and indie SaaS builders implementing the Harmonize phase of Data Cloud. It covers DMOs, field mappings, relationships, identity resolution, unified profiles, data graphs, and universal ID lookup, with concrete sf data360 commands to list objects, describe tables, and audit mappings. Use it when streams and DLOs already land data but unified individuals or accounts do not appear, or when you need to align a custom object to ssot models. The skill expects CLI access to your org and complements preparing-datacloud for ingestion and segmenting-datacloud for downstream activation. It reduces guesswork in schema unification so agents can propose mapping steps that match Salesforce terminology.599installs47Activating Datacloudactivating-datacloud is an agent skill in the Salesforce sf-skills Data Cloud family focused on turning modeled segments and actions into live downstream delivery. Solo and indie builders who ship on Salesforce—or consultants automating org setup—use it when they need to activate a segment, enumerate existing activation targets, create a data action target for an integration, or diagnose readiness blockers before data leaves Data Cloud. The skill steers conversation toward concrete CLI workflows rather than vague CDP theory, aligning with partner-style operational tasks enterprises expect from scripted agents. It complements orchestrating-datacloud by narrowing scope to activation and push paths, with template assets for consistent metadata definitions. Expect shell access to the Salesforce CLI against a authenticated org; this is not a generic REST tutorial but an opinionated activation playbook tied to data360 subcommands and family credits documentation.596installs48Segmenting DatacloudSegmenting-datacloud is a Salesforce Data Cloud skill for audience and insight work: defining segments, publishing them, running calculated insights, and diagnosing zero-member or surprising counts. It targets builders and revops-minded solos who already ingest data into Data Cloud and now need repeatable CLI-oriented steps instead of guessing in the UI. Example flows include high-value customer segments, verifying insight outputs, and fixing segment SQL. Shared JSON templates for segments and calculated insights live alongside the orchestrating-datacloud skill, so this skill is the execution-focused sibling in a phased Data Cloud workflow. Use it when member counts matter for campaigns, personalization, or reporting—not when you are still mapping sources and identity resolution from scratch.594installs49Creating B2b Commerce Storecreating-b2b-commerce-store is a Salesforce-focused agent skill that prevents the common B2B Commerce failure mode: treating the storefront as the whole store. It explains that the Commerce Store is org runtime configuration—buyer groups tied to accounts, entitlement policies, catalogs, price books, payment gateways, tax providers, shipping, and search indexes—created through the Commerce app rather than `sf project deploy`. Storefront work comes after that foundation so visibility, pricing, and checkout policies already exist. Solo builders on Agentforce-era stacks use it during Build when standing up a B2B portal on existing Salesforce CRM data. It does not replace Salesforce admin access or partner solution design, but it gives agents accurate object names and sequencing so implementation plans respect platform constraints.580installs50Deploying Omnistudio DatapacksDeploying OmniStudio Datapacks is a Salesforce-focused agent skill for solo builders and small teams who must move Vlocity/OmniStudio DataPacks into orgs without ad-hoc CLI guesswork. It encodes the Vlocity Build command model: scope work with a manifest (for example Product2 GUIDs), keep expansion paths explicit, run validation before deployment, and use retry-oriented recovery when packs partially fail. The skill emphasizes reproducible job files—project path, expansion path, parallelism, and header-only support flags—so the same bundle deploy can be replayed and documented. Example transcripts walk through deploying offer bundles such as Business Internet Plus, including companion artifact consistency and namespace placeholders. It is not a substitute for designing the catalog; when dependencies and EPC structure matter, a companion modeling skill applies. Use this when you already have local DataPack exports and need orchestration, triage, and a written audit trail under Salesforce constraints.579installs51Modeling Omnistudio Epc CatalogModeling Omnistudio EPC Catalog is an agent skill aimed at solo builders and small teams who ship on Salesforce and need correct Enterprise Product Catalog (EPC) payloads without hand-rolling brittle JSON. It focuses on Vlocity/Omnistudio conventions: attribute categories, attribute definitions, display names, sequences, and lookup keys that must line up with packaged metadata codes. Use it when you are extending CPQ-style catalogs, contract-term attributes, or product bundles and your agent needs a repeatable pattern for `%vlocity_namespace%__*` fields and `VlocityDataPackType` structures. The skill does not replace org-specific discovery or security review; it accelerates accurate catalog modeling during implementation so quotes, orders, and configurators resolve attributes consistently in Omnistudio.575installs52Building Omnistudio Integration ProcedureBuilding OmniStudio Integration Procedure is an agent skill for Salesforce builders who need to scaffold OmniStudio Integration Procedures (IPs) as structured JSON rather than clicking only through OmniStudio Designer. It suits solo implementers on Service Cloud, Industry Cloud, or Experience Cloud projects who must chain DataRaptor Extract actions, Set Values steps, and failure semantics with consistent PropertySetConfig strings. The skill supplies concrete element payloads—including bundle names, cache flags, response JSON paths, and vlcSI placeholders—so an agent can generate repeatable IP fragments aligned to your naming conventions. It also references a formal validation report with six scored categories totaling up to 110 points, helping you review design and structure before activating flows. Invoke it when standing up new Type/SubType IPs, documenting omniscripts’ server-side counterparts, or standardizing extract-and-map patterns across orgs. Outputs are deployment-ready OmniProcess element definitions you can merge into your migration pipeline or manual import workflow.572installs53Building Omnistudio OmniscriptBuilding OmniStudio OmniScript is a Salesforce-focused agent skill for composing OmniScript and OmniProcess metadata as structured JSON. Solo builders and small teams on Experience Cloud or Service Cloud use it when they need consistent step layouts, text blocks, and property-set configuration instead of clicking through OmniStudio for every variant. The skill encodes common OmniProcess element shapes—steps at Level 0, child elements at Level 1, validation and remote-call property sets—so your agent can draft flows that align with OmniStudio conventions. It fits builders who already run against a Salesforce org and want agent-assisted scaffolding for intake wizards, case flows, or onboarding scripts. Pair it with org access, naming standards, and deployment practices; it accelerates JSON generation, not business-rule design or full OmniStudio QA.571installs54Building Omnistudio Callable ApexBuilding OmniStudio Callable Apex is an agent skill for the Build phase that gives agents a vetted Apex template for Salesforce Industries OmniStudio integrations using System.Callable. Solo builders and small implementation teams use it when Open Interface or similar callers pass { inputMap, options } and you need consistent parsing, null-safe maps, and switch-on-action routing instead of one-off Invocable-only classes. The readme documents the same contract as legacy VlocityOpenInterface while remaining compatible with callers that omit the inputMap wrapper. Replace placeholder class and action names, fill validation and coercion in the private handler, and wire outputs back through the map pattern your OmniScript expects. It reduces integration bugs during ship because argument-shape mistakes are caught in a single callable entry point rather than scattered across multiple Apex classes.570installs55Building Omnistudio FlexcardBuilding OmniStudio FlexCard is a Salesforce-focused agent skill for creating OmniStudio FlexCard metadata: names, versions, datasource configs wired to Integration Procedures, and PropertySetConfig state layouts. Indie consultants and solo builders on Revenue Cloud or Service Cloud use it when the product experience lives inside a customer org and FlexCards must load data via IP methods like typed subtypes with recordId maps. The skill mirrors official tooling patterns for data source binding and card structure, including single-card summary layouts and inactive draft states before activation. It is narrowly aimed at OmniStudio authoring—not general React dashboards. Expect JSON-heavy templates, Salesforce-specific field naming, and enterprise CRM constraints. Prism tags it for builders who already committed to Salesforce as the integration layer and need repeatable FlexCard scaffolding instead of manual Studio clicking.568installs56Building Omnistudio DatamapperBuilding OmniStudio Data Mapper is a Salesforce-focused agent skill that walks builders through creating OmniDataTransform definitions used in OmniStudio Integration Procedures and industry cloud experiences. It structures work across phases including scoring output and a final completion summary so field mappings, object targets, and naming conventions stay auditable before activation. Templates cover Extract, Transform, Load, and Turbo Extract patterns with illustrative JSON for parent transforms and per-field OmniDataTransform items including filters and ordering. A weighted scorecard rates design and naming, field mapping, data integrity, performance, and documentation, with clear gates for deploy versus fix-required states. Solo builders on small Salesforce teams can use it to reduce rework when connecting CRM objects to digital workflows. It assumes familiarity with Salesforce metadata and OmniStudio—not generic REST API design.567installs57Analyzing Omnistudio Dependenciesanalyzing-omnistudio-dependencies is a Salesforce-focused agent skill for architects and solo consultants who must see how OmniStudio pieces reference each other before a safe change. Unlike standard Salesforce metadata with obvious lookup relationships, OmniStudio wires dependencies inside JSON configuration payloads—PropertySetConfig, Definition, and input/output object names—so grep on field APIs alone will miss edges. The skill documents directional patterns: OmniScripts call integration procedures and Data Mappers; IPs nest other IPs and remote Apex; FlexCards pull from IPs, Apex, or child cards. It is phase-specific to Build integrations work on Revenue Cloud, Service, or industry accelerators where OmniStudio is the UX and orchestration layer. Use when planning refactors, impact analysis, or documenting blast radius—not when the task is unrelated CRM admin. Intermediate complexity assumes familiarity with OmniStudio component types and Salesforce packaging vocabulary.565installs58Running Code Analyzerrunning-code-analyzer is an agent skill for Salesforce indie teams and solo consultants who need a repeatable static analysis pass over Apex and Lightning Web Components before deploy. It orients the agent around Code Analyzer output shape: metadata block with executedAt, filesAnalyzed, and violationCount, plus per-finding rule name, engine (pmd or eslint), severity, message, and location in force-app paths. Typical findings include CRUD permission gaps, missing ApexDoc, unsafe innerHTML in LWC, and style rules with auto-fix hints. Use in Ship when reviewing a branch or preparing a release candidate on Salesforce DX projects, not when greenfield scaffolding in Build alone. Intermediate complexity assumes Salesforce CLI or analyzer tooling is available in the project. Outcome is a structured violation backlog you can fix or waive with traceability rather than manual grep across dozens of metadata files.331installs59Integrating B2b Commerce Open Code ComponentsIntegrating B2B Commerce Open Code Components is a Salesforce-focused agent skill that pulls the official open-source B2B Commerce component library from GitHub and installs it into your store’s site metadata so every component and label shows up in Experience Builder. Solo builders and small commerce teams use it when they want the full OSS palette without manually hunting folders in the forcedotcom repository. The workflow is deliberately explicit: the agent must explain what each git clone and copy command does before running it, aligning with safe operator habits on production orgs. It targets phrases like integrate open code components, open source B2B commerce, and adding OSS blocks to new or existing stores. After integration, merchandisers can compose pages from the same open components Salesforce publishes upstream, reducing bespoke LWC duplication for standard commerce patterns.265installs60Applying Cms BrandApplying CMS Brand is a Salesforce CMS integration skill that searches an org for existing brand definitions, retrieves structured brand instructions, and applies voice, tone, color, and typography rules to content your agent produces. Solo builders on Experience Cloud or Sales Cloud content stacks use it whenever a prompt mentions branding—phrases like apply our brand voice or match our guidelines should route here instead of generic tone guessing. The skill deliberately excludes hunting logos or images (other skills handle media) and does not author net-new brand strategy documents. It expects MCP tools get_brand_instructions and search_brands to be available so retrieval stays authoritative rather than hallucinated palette names. Placement on Build/docs reflects copy and page generation, but the same flow supports launch landing pages and lifecycle emails when those assets are generated from the same CMS source of truth.264installs61Building Mobile AppsBuilding-mobile-apps is a Salesforce skills router for indie and solo developers who need a native Swift or Kotlin app tied to an org—not a generic mobile tutorial. When someone says build a Salesforce iOS app, add Android login, set up Mobile SDK, enable MobileSync or SmartStore offline, or embed Agentforce chat, the agent should start here instead of guessing implementation steps. The skill forces a short disambiguation on SDK family (Mobile SDK versus Agentforce SDK) and platform (iOS versus Android), because child skills are platform- and SDK-specific and wrong routing wastes iteration time. It explicitly declines non-Salesforce mobile work, cross-platform stacks without Salesforce integration, pure branding on Mobile Publisher, and Salesforce-adjacent web surfaces like LWC or Experience Cloud. Outcome is a clean handoff to the correct downstream skill in the sf-skills family so implementation, credentials, and SDK versions stay consistent with Salesforce’s documented paths.1installs62Generating Ui Bundle Custom Appgenerating-ui-bundle-custom-app is a Salesforce-focused generator skill for indie builders and consultants packaging React UI bundles into Lightning Experience. It tells your agent exactly how to author a new CustomApplication metadata file—not to modify an existing app record—and where that file lives under the default SFDX package directory from sfdx-project.json. The default XML template wires branding, Small and Large form factors, standard navigation, Lightning UI type, and the uiBundle reference that points at your namespaced bundle. Use it when you are standing up a fresh hosted UI bundle app alongside other Salesforce metadata in a scratch or packaging pipeline. The skill is narrow by design: metadata shape and file placement, not org deployment orchestration or Apex security review. Pair it with Salesforce deploy and testing skills once the application record exists.1installs63Reviewing Lwc Mobile OfflineReviewing LWC Mobile Offline is an agent skill that acts as a specialized reviewer for Lightning Web Components destined for Salesforce Mobile App Plus and Field Service Mobile in offline mode. Komaci pre-primes the data graph only when components follow patterns the static analyzer can understand; this skill trains the agent to hunt three failure classes: modern conditional rendering directives that must become legacy if:true branches, inline GraphQL in @wire adapters that must move to getters, and violations surfaced by the Komaci-oriented ESLint plugin such as private wire properties and reactive getters with side effects. Solo Salesforce builders and small teams use it during pre-release review so field technicians do not hit blank screens offline. Output is categorical findings with concrete rewrite guidance, not generic style nitpicks. It assumes you already write LWC and deploy to Salesforce mobile contexts.1installs64Using Mobile Native CapabilitiesUsing Mobile Native Capabilities is a Salesforce-focused agent skill that supplies grounding context for Lightning Web Components that trigger native in-app review dialogs via AppReviewService. Solo builders shipping on Salesforce mobile—not generic React Native—use it when an agent needs accurate TypeScript signatures, factory imports, and option flags before generating or reviewing LWC code. The readme centers on requestAppReview, configuration objects, and links to Salesforce’s documented API so codegen stays aligned with platform contracts rather than hallucinated mobile SDKs. It fits builders who already deploy on Experience Cloud or Salesforce mobile containers and want review prompts that respect “already asked” policies. Treat it as a narrow integration reference during implementation and code review, not a full App Store optimization or growth analytics playbook.1installs