jaganpro/sf-skills
34 skills36.5k installs14.2k starsGitHub
Install
npx skills add https://github.com/jaganpro/sf-skillsSkills in this repo
1Sf Apexsf-apex is an agent skill for solo builders and small teams shipping on Salesforce who need production-grade Apex instead of copy-paste snippets. Invoke it when writing or refactoring classes and triggers, designing trigger frameworks, building Queueable or Batch jobs, adding invocable methods for Flow, or reviewing bulkification, sharing rules, and test coverage on existing .cls and .trigger files. The skill applies a 150-point score spread across eight categories so reviews stay evidence-based rather than vibes-based. It clearly hands off LWC front-end work to sf-lwc, Flow XML to sf-flow, SOQL-only tasks to sf-soql, and org deployment to sf-deploy—keeping Apex as the single owner for server logic. Gather class type, async pattern, and security context before generation. Skip it for pure JavaScript UI, declarative Flow-only changes, or metadata deploy steps with no Apex edits.1.4kinstalls2Sf Lwcsf-lwc is an agent skill for solo builders and small teams implementing features on Salesforce with Lightning Web Components. It packages a procedural Apex controller template that shows how to expose data to LWC correctly: cacheable methods for @wire service with automatic refresh semantics, and non-cacheable methods for creates and updates, each wrapped in explicit error handling. Security is treated as default rather than optional—queries use WITH SECURITY_ENFORCED and the class runs with sharing so FLS and record access do not get bypassed in generated code. Bulk-safe list retrieval patterns with escaped search terms and sensible record limits help indie admins avoid governor-limit footguns when agents scaffold CRUD UIs. Use this skill during Build when you need a consistent backend contract for a new LWC screen rather than copying anonymous Apex snippets from forums. It does not replace Salesforce release management or full test strategy; it accelerates the controller layer so you can focus on component markup and UX.1.4kinstalls3Sf Flowsf-flow is an agent skill that supplies a structured Salesforce Flow XML template for Einstein-powered Decision elements. Solo builders and small teams on Salesforce use it when they want runtime LLM evaluation of branching logic—sentiment, classification, or custom outcomes—instead of maintaining brittle formula conditions on every rule. The template encodes the LlmPrompt attribute pattern on the parent decision and on named rule outcomes, explains that AI-evaluated rules omit manual condition blocks, and reminds you to embed merge fields such as record fields so the model sees real data. Placeholders cover API names, labels, and prompt text you replace before deploying to an org. It fits builders already committed to Flow who need a repeatable starting point for AI decisions, not a full Flow authoring tutorial or non-Salesforce workflow engines.1.3kinstalls4Sf Metadatasf-metadata is an agent skill that supplies Salesforce CustomField XML templates for common field types such as checkbox and currency. Solo and indie builders extending a Salesforce org can paste or fill placeholders—field API name, label, default value, description, and inline help—instead of guessing SOAP structure. The templates encode platform rules (for example mandatory checkbox defaults and typical currency scale) so generated metadata is deployable via metadata API or source-driven workflows. It fits builders who ship SaaS or internal tools on Salesforce and want consistent, repeatable field definitions during the build phase rather than one-off XML from memory.1.3kinstalls5Sf Soqlsf-soql is an agent skill that encodes Salesforce Object Query Language patterns for solo builders shipping on Salesforce or integrating CRM data into internal tools. It focuses on aggregates—counts with and without filters, distinct counts, sums, averages, min/max, and combined rollups with date filters—plus GROUP BY grouping so agents generate valid SOQL instead of guessing syntax. Use it when you need reporting-style queries, validation counts, or pipeline metrics from standard objects like Account, Contact, and Opportunity. The skill is reference-oriented procedural knowledge for Claude Code, Cursor, and similar agents working in a Salesforce repo or alongside Apex and Flow. It does not run queries itself; it guides correct SOQL construction aligned with Salesforce governor limits and field API names you supply from your org schema.1.3kinstalls6Sf Debugsf-debug packages Salesforce Apex performance benchmarking patterns drawn from Advanced Apex Programming and community benchmarking write-ups. Solo builders and small teams use it when a trigger, service, or loop suddenly threatens CPU time or row limits and anecdotal fixes are not enough. The skill centers on Anonymous Apex snippets: a simple timed loop for one approach and a BenchmarkComparison-style class that warms up the JVM, repeats work thousands of times, and declares a winner between two implementations. That workflow fits indie Salesforce extensions, managed-package hot paths, and integration batches where a few milliseconds per row compounds into failed jobs. Invoke it while hardening backend logic before release or when revisiting legacy Apex during Operate iteration, always in a sandbox with realistic data volumes rather than production.1.3kinstalls7Sf DeploySf-deploy is a Salesforce shipping skill centered on the Salesforce CLI deploy workflow and a destructive changes manifest template. Solo builders and small consultancies shipping on Salesforce use it when they must promote packaged metadata to sandbox or production and optionally delete obsolete components in the same transaction. The embedded destructiveChanges.xml shows how to declare ApexClass, ApexTrigger, CustomObject, CustomField, LightningComponentBundle, and AuraDefinitionBundle removals, paired with sf project deploy start flags for pre- or post-destructive phases. It does not replace org-specific release checklists—validation runs, test levels, and backup policies still belong to your team—but it gives agents a concrete, copy-paste-safe artifact for the most failure-prone part of DX deploys: ordering destructive deletes with the main package.1.3kinstalls8Sf Permissionssf-permissions is an agent skill that helps solo builders and small teams analyze Salesforce authorization without shipping PSLab-style Apex into every org. Inspired by Oumaima Arbani’s PSLab, it encodes hierarchy visualization, reverse lookups (“who can access X”), and user-effective permission tracing using Python and the Salesforce API. Indie founders integrating CRM data, building managed packages, or hardening sandboxes before production cutover use it to answer access questions quickly from Claude Code or similar terminals. It suits builders who need repeatable permission reports across dev, staging, and prod orgs rather than one-off Setup UI clicking. The skill emphasizes setup entity access queries and rich terminal output for agent consumption. It does not replace formal security sign-off or org-wide entitlement governance policies—you still validate changes with admins and change control.1.3kinstalls9Sf TestingSF Testing is an agent skill for indie consultants and solo Salesforce builders who must ship Apex without deployment failures from thin or messy tests. Salesforce requires meaningful coverage before promote; this skill gives agents a repeatable class layout: centralized TestSetup data via a factory, then positive paths, negatives, and bulk scenarios with explicit GIVEN blocks and SOQL fixtures. Placeholders like ClassName and ObjectName let you stamp out tests aligned to org conventions instead of one-off chat snippets that miss bulk or failure cases. It assumes you already have Apex to cover and a TestDataFactory or equivalent—you fill method bodies and assertions. Use while hardening a feature branch before release or when retrofitting coverage on legacy triggers and services.1.3kinstalls10Sf Datasf-data is an agent skill for solo Salesforce builders and indie consultancies who must seed orgs with thousands of Accounts or related records without hitting governor limits. The readme frames bulk insert of 10,000+ records and steers you away from one-shot Anonymous Apex toward sf CLI bulk CSV import, Data Loader, or a Database.Batchable<Integer> implementation such as BulkAccountCreator executed via Database.executeBatch. It fits multi-phase work: during Build when you wire integrations and test APIs, during Ship when you validate performance and reports at scale, and during Validate when you prototype against realistic volumes. Agents use it to scaffold batch classes, CSV-oriented workflows, and commentary on when each approach wins so migration and Bulk API 2.0 exercises stay reproducible in sandboxes.1.3kinstalls11Sf Integrationsf-integration packages Salesforce-side integration know-how for solo builders and small teams shipping features on the Salesforce platform. It emphasizes production-grade HTTP callouts: classifying errors, retrying only when it makes sense, and working within Apex constraints where Thread.sleep is unavailable so backoff often belongs in Queueable jobs. Use it when your agent is scaffolding integrations between Salesforce and REST services, hardening callouts against timeouts and rate limits, or turning brittle one-shot Http.send into maintainable handlers. The material fits indie builders who own both the CRM org and the connected app, not teams that only consume Salesforce as a black-box SaaS. Expect code-forward patterns rather than click-config tutorials; you should already understand Apex basics, named credentials or remote site settings, and governor limits. Pair with testing and security review before shipping callouts that touch customer or payment data.1.2kinstalls12Sf Diagram Mermaidsf-diagram-mermaid is a template skill for solo builders and small teams shipping Salesforce Agentforce service agents. It provides ready-made Mermaid flowchart patterns that mirror how agents are structured in practice: agent description, topic inventory, behavioral instructions, and nested topic blocks with scoped actions tied to Apex or Flow. Invoke it when you need to document an existing agent, plan new topics and actions before configuration, or visualize conversation routing for a review—not when you need executable Apex or metadata deployment. The output is diagram source you can paste into docs, PRs, or architecture wikis, which makes agent behavior legible to non-builders and reduces rework when topics overlap or escalation rules are unclear. It pairs naturally with Salesforce agent design work elsewhere in the journey and does not replace Agentforce setup or testing in org.1.2kinstalls13Sf Connected Appssf-connected-apps is an agent skill for solo builders and small teams shipping Salesforce-backed SaaS who must get OAuth right before runtime callouts work. It triggers when someone configures OAuth flows, JWT bearer auth, Connected Apps, or edits Connected App and External Client App metadata— and explicitly stops short of Named Credentials, permission-set policy analysis, or Apex endpoint code so you do not mix concerns. The skill applies a 120-point rubric across six categories to stress-test scope design, callback URLs, certificate strategy, and modern ECA patterns versus legacy Connected Apps. Intermediate-to-advanced Salesforce integration knowledge is assumed. You should already know which client needs which flow. Outcomes are reviewable XML-oriented configs and architectural choices your sf-integration skill can consume next. Prism places it on Build/integrations as the canonical shelf for app-side OAuth registration, not org-wide access governance.1.2kinstalls14Sf Ai Agentscriptsf-ai-agentscript guides solo builders and small Salesforce teams through Agent Script—the code-first DSL for deterministic Agentforce agents. Invoke it when users write or refactor .agent files, design finite-state topic flows, resolve instructions, implement slot filling, or run the Agent Script CLI for authoring bundles, validation, preview, publish, and activate. The skill documents MIT-licensed patterns aligned to API v66.0+, Agentforce licensing, and Einstein Agent User requirements for Service Agents. It contrasts with adjacent skills: use sf-ai-agentforce for Builder metadata, sf-ai-agentforce-testing for test harnesses, and sf-ai-agentforce-persona for persona design. Internal metadata cites version 2.9.0, a 100-point scoring model across six categories, PASS validation with 24 validation agents, and 0-shot generation checks against representative sample agents. Builders get repeatable control over routing, variables, actions, and publish behavior instead of ad-hoc Builder clicks. Start from the activation checklist reference for the shortest path to a publishable bundle.1.2kinstalls15Sf Diagram Nanobananaprosf-diagram-nanobananapro packages prompt templates for Salesforce integration architecture and core-object ERDs aimed at consultant-grade visuals. Solo builders and fractional architects use it when they need a landscape integration diagram—cloud Salesforce, middleware, ERP endpoints, protocol-labeled arrows—or an ERD that matches the architect.salesforce.com aesthetic without opening a separate design tool from scratch. Templates enumerate systems, integration patterns, authentication layers, and styling cues (pastel palette, legends, hub-spoke or left-to-right layout). Examples show invoking Gemini with a fully specified integration narrative including OAuth badges and failed-message queues. The skill is generative documentation: it does not deploy Salesforce metadata or validate integration throughput. Pair it with your actual integration spec from Build/integrations so diagrams stay truthful under client review.1.2kinstalls16Sf Ai Agentforcesf-ai-agentforce is an agent skill for solo builders and small teams shipping AI agents on Salesforce. It consolidates up-to-date direction for GenAiPromptTemplate-based Prompt Builder work, Agent Script authoring, and the metadata types you need when using Agentforce DX rather than scattered blog posts. Use it when you are implementing service, sales, or internal copilots inside a Salesforce org and need a single procedural reference that matches current Einstein GenAI documentation. The skill emphasizes correct template structure, builder sequencing, and deployable metadata so your agent does not break on the next platform release. It fits Prism’s build-phase catalog for CRM-native agent work where the product shape is SaaS on Salesforce and the integration surface is APIs and metadata tooling, not a generic standalone chatbot repo.1.2kinstalls17Sf Ai Agentforce TestingSf-ai-agentforce-testing is a Salesforce-focused agent skill for building YAML test specifications compatible with Salesforce CLI agent test commands. It targets builders shipping Agent Script (.agent / AiAuthoringBundle) bots where multi-topic routing hides real action coverage: the first cycle often spends on start_agent topic transitions, so Apex and Flow may not fire in naive single-utterance tests. The skill explains the definition versus invocation action layers and shows how conversationHistory pre-positions the bot so tests assert the second-cycle behavior you care about. Solo indie teams on Agentforce use it after authoring an agent, when they need repeatable JSON-result test runs in a target org. It is procedural test-spec guidance tied to sf CLI, not a substitute for org security review or full UX manual QA.1.1kinstalls18Sf Ai Agentforce ObservabilitySalesforce AI Agentforce Observability is an agent skill oriented to solo builders and small teams running Agentforce in real orgs who need to see what the agent did turn by turn. It documents a Python harness that loads STDM parquet entities, rebuilds conversation timelines, surfaces step-level LLM reasoning and tool inputs/outputs, and highlights failed sessions for faster root cause analysis. Use it after traces or exports land in a controlled data directory—not as a substitute for Salesforce platform configuration. The readme emphasizes sensitive artifacts: network captures, session tokens, and org-specific URLs stay out of version control. Prism lists it for operators who already deploy agents on Salesforce and need repeatable offline analysis instead of clicking blindly through Builder logs.1.1kinstalls19Sf Docssf-docs is a prompt-only Salesforce documentation skill for agents building on the platform—not a local corpus, indexer, or PDF pipeline. It teaches a practical retrieval playbook when official pages are hostile to naive fetch: JavaScript-heavy developer guides, Help article shells, and architect or admin sites that need rendered extraction. Solo builders use it to ground Apex, REST API, Lightning Web Components, Agentforce, and SLDS answers in first-party sources, including chasing the correct child article instead of stopping on a landing page. The skill explicitly rejects weak shells and unofficial summaries. An optional Python wrapper can route help.salesforce.com URLs through a dedicated extractor for structured text. Install it when your agent keeps hallucinating Salesforce APIs or citing outdated blog posts instead of current Help IDs and developer references.1.1kinstalls20Sf Ai Agentforce Personasf-ai-agentforce-persona is an agent skill for solo and small teams shipping Salesforce Agentforce agents who need repeatable persona encoding instead of one-off prompt drafts. It transforms a persona markdown source into production-oriented Agent Script fragments: a system block with YAML literal instructions covering identity, dimensional behavioral rules, phrase book, chatting style, tone boundaries, and never-say constraints, plus static welcome and error messages in voice. When topics and actions are defined, it also outputs per-topic reasoning calibration and action-level loading text marked for progress indicators. Use it during agent configuration when you want consistent voice across channels and topics before wiring tools and flows. The output is structured for Agent Script tooling rather than generic chat system prompts, which matters for compliance-heavy customer-facing agents where tone drift is costly.1.1kinstalls21Sf Datacloudsf-datacloud is an agent skill aimed at solo builders and small consultancies implementing Salesforce Data Cloud—not generic CRUD APIs, but the metadata-shaped objects that power unified customer profiles, segment activation, and calculated insights. The packaged examples show how to declare activation targets such as CRM or webhook destinations, bind published segments like High Value Customers to those targets, and author calculated metrics (for example lifetime spend aggregated from Sales Order DMOs). It also sketches data action targets and definitions for notifying downstream systems when segment rules fire, plus a Customer 360 Data Graph rooted on the unified Individual entity with selectable profile fields. Use it when your agent session needs concrete JSON patterns instead of guessing developerName, DMO references, and activation linkage fields. It assumes familiarity with Salesforce’s Data Cloud object model and is strongest during Build while you connect marketing, sales, and service data products into one activatable customer graph.883installs22Sf Industry Commoncore Omniscriptsf-industry-commoncore-omniscript is an agent skill that supplies canonical JSON fragments for Salesforce OmniStudio OmniScripts in Industry Cloud-style projects. Solo builders and small implementation teams use it when they need consistent Step, Text Block, and process-root records instead of clicking through Setup or guessing escaped PropertySetConfig strings. The skill fits the build phase when you are modeling multi-step guided experiences, knowledge options, validation modes, and LWC runtime settings on OmniProcess objects. It is template-oriented procedural knowledge: your agent fills placeholders and sequences elements while you retain responsibility for activating versions, data raptors, and integration procedures in the org. It does not replace OmniStudio UI review, security review of remote classes, or deployment pipelines—it accelerates structured JSON generation for common core patterns so implementation chatter stays aligned with Salesforce metadata shape.881installs23Sf Industry Commoncore DatamapperSF Industry Common Core Data Mapper is a template-oriented skill for builders implementing Salesforce OmniStudio data integration on industry cloud programs. It supplies starter JSON for Extract, Load, and Transform Data Mapper records plus item-level mapping rows you customize with object API names, output nodes, and filter semantics. The content assumes you are composing DR_* components that feed Integration Procedures and OmniScripts rather than writing one-off Apex transforms. Naming conventions embed object and purpose tokens so downstream dependency tracing stays readable. Acknowledged community tooling highlights how mappers relate to Integration Procedures and OmniScripts—useful when you need consistent metadata before activation. New records default to inactive, which fits promote-through-environments workflows common on solo consultants and small SI teams shipping configurable Salesforce solutions.877installs24Sf Industry Commoncore Omnistudio AnalyzeSf-industry-commoncore-omnistudio-analyze is an agent skill for solo Salesforce Industries builders and small implementation teams who need to understand how OmniStudio pieces connect before they edit anything. OmniScripts, Integration Procedures, FlexCards, and Data Mappers form a dense dependency web; a small PropertySet or Definition JSON change can break downstream cards, IPs, or transforms. The skill encodes analysis patterns from the OmniStudio community and official schema knowledge: how to traverse components, interpret FlexCard Definition JSON and data sources, and reason about blast radius on Core namespace objects. It fits agent-assisted refactors, upgrade planning, and pre-merge reviews where you want a structured dependency pass instead of manual Setup clicking. Use it when you are about to rename, repoint, or delete OmniStudio assets or when onboarding an agent to an unfamiliar org footprint.877installs25Sf Industry Commoncore Flexcardsf-industry-commoncore-flexcard helps Salesforce practitioners—not generic indie web stacks—author FlexCard metadata that follows Industry Common Core Integration Procedure naming. The skill ships a concrete JSON template: child card type, Integration Procedures datasource, Active state styling with SLDS classes, and templated fields for author and description. Solo builders only matter here if you personally implement Vlocity or OmniStudio on a Salesforce org; otherwise treat this as an enterprise integration artifact. When it applies, your agent can fill {{IPType}}_{{IPSubType}} methods, bind recordId from context variables, and keep PropertySetConfig consistent with community and official OmniStudio MCP guidance referenced in the credits. Advanced complexity: assumes familiarity with FlexCards, IPs, and Salesforce packaging. Outputs are deployable metadata JSON, not a running UI by itself.874installs26Sf Datacloud Retrievesf-datacloud-retrieve is an agent skill for solo builders and integrators implementing Salesforce Data Cloud retrieval on structured Data Model Objects. It documents how to stand up hybrid search indexes that tie a source DMO to chunk and vector companion objects, including search type, embedding model choices, ranking configurations, and field-level chunking such as passage extraction with token limits and HTML stripping. The skill fits teams building RAG or in-org search over Data Cloud without hand-rolling every developerName and configuration block from scratch. It assumes familiarity with Salesforce metadata patterns and aligns with sibling skills in the sf-datacloud family for attribution and upstream mapping. Use it during backend and agent-tooling work when you need repeatable retrieve/index definitions before wiring queries or Einstein/Agentforce-style flows.872installs27Sf Datacloud ConnectSf-datacloud-connect helps builders working in the Salesforce Data Cloud ecosystem stand up connectors without hand-typing brittle JSON. It provides copy-ready structures for a Heroku Postgres ingress connector—including credentialType, user, password, host/port JDBC URL, and database name—and for Ingest API connectors plus sample object schemas with Id, Name, Timestamp, and Value fields. Solo consultants and small teams using Claude Code on Salesforce projects can use the skill to keep naming consistent (connectorType, label, name, method) and to separate secrets from structural parameters before deployment in org tooling or metadata pipelines. It assumes familiarity with Data Cloud concepts and pairs with the broader sf-datacloud-* skill family for attribution and upstream sync. Use during integration sprints when you connect operational databases or event streams into Data Cloud, then validate mappings and activation in your org—not as a replacement for Salesforce’s connector setup UI or security review.870installs28Sf Industry Commoncore Integration ProcedureSf-industry-commoncore-integration-procedure targets Salesforce Industry Cloud and OmniStudio practitioners who build Integration Procedures (IPs) as reusable server-side orchestration. The skill surfaces JSON-shaped templates for common elements: a DataRaptor Extract Action wired to a named bundle with standard PropertySetConfig flags, a Set Values step that maps output keys, and a parent OmniProcess record marked as an integration procedure with Type, SubType, Language, and WebComponentKey. Solo implementers using AI agents can drop these structures into metadata migration, scratch org seeding, or documentation-first design before activating flows in Vlocity/OmniStudio tools. Complexity is advanced because PropertySetConfig is escaped JSON inside JSON and small syntax errors fail deployment. Use when you are extending Common Core or industry accelerators and need consistent element naming and sequencing—not for Omniscript UI-only changes or unrelated Apex integrations.870installs29Sf Datacloud Preparesf-datacloud-prepare is a Salesforce-focused agent skill that gets solo builders and integrators ready to push records into Data Cloud through the Ingestion API. It spells out external client app credentials, login and tenant URLs, JWT private key paths, and connector/object naming so a follow-on send-data script can run without guessing org-specific setup. The readme ties prepare work to schema upsert CLI commands and optional data stream creation in the UI, with reference JSON for connections and schemas kept in sibling example paths. It assumes you already target a specific connector such as the Badge_Scanner / Badge_Scan example but the pattern generalizes to other objects. Intermediate complexity reflects Salesforce auth, Data Cloud tenancy, and multi-step connector lifecycle. Use in Build when wiring event or product data into Customer 360 pipelines before operational monitoring of ingest health.868installs30Sf Datacloud Actsf-datacloud-act is an agent skill for teams implementing Salesforce Data Cloud: it encodes activation and downstream delivery workflows so Claude Code, Cursor, or Codex can follow consistent steps instead of improvising from scattered admin docs. It sits in the build phase under integrations because turning on Data Cloud and pushing data to activated destinations is platform wiring, not ideation or launch marketing. The published readme is thin relative to sibling sf-datacloud skills, so practitioners should pair it with the family’s CREDITS.md and UPSTREAM.md for attribution and source mapping. Prism lists it for builders who already committed to Salesforce’s stack and need repeatable agent guidance for act-and-deliver milestones. Solo indie builders without a Salesforce tenant or Data Cloud license will get little value; small teams on Customer 360 are the realistic audience.864installs31Sf Industry Commoncore Callable Apexsf-industry-commoncore-callable-apex is an advanced agent skill for solo builders and small teams extending Salesforce Industries and OmniStudio with Apex callables. It consolidates official migration guidance from VlocityOpenInterface and VlocityOpenInterface2 toward System.Callable, including invokeMethod signatures with inputMap, outputMap, and options maps. The skill supports action contract design, response shaping, and bundled examples called out by the primary contributor. It assumes you are already in an Industries org wiring Integration Procedures, DataRaptors, or custom actions—not learning Apex from zero. Use it when refactoring legacy Vlocity interfaces or standardizing on platform Callable for testability and long-term support.842installs32Sf Flex Estimatorsf-flex-estimator is an agent-invokable Python skill that totals Salesforce Flex Credit consumption for Agentforce and Data Cloud scenarios. It encodes constant FC_COST per credit, a Private Connect surcharge multiplier, structured PROMPT_RATES for model tiers, ACTION_RATES for agent actions including voice and sandbox, and an extensive DC_RATES table for Data 360 operations from batch prep through real-time pipelines, with DC_ALIASES so inputs like prep or unification resolve cleanly. Solo builders and small teams on Salesforce can run what-if estimates during validation instead of discovering bill shock after agents go live. The skill is intermediate: you need approximate monthly volumes and which Salesforce SKUs you plan to enable. It does not deploy orgs or provision licenses—it outputs calculated credit and cost projections you can drop into a scope doc or pricing slide.720installs33Sf Industry Cme Epc Modelsf-industry-cme-epc-model is an agent skill aimed at solo builders and small teams implementing Salesforce with Vlocity Enterprise Product Catalog for CME verticals. It encodes industry-specific attribute categories, contract details, and catalog lookup patterns so an agent can reason about or generate consistent Vlocity metadata instead of hand-copying opaque JSON from org exports. Use it during build when you are standing up or extending product catalogs, contract terms, and attribute display rules in a Vlocity-enabled org. The readme fragment centers on Contract Term configuration linked to VEPC attribute records—typical of CPQ and subscription quoting flows. It is not a general Salesforce admin cheat sheet; it is narrowly scoped to the CME EPC model shape. Pair it with broader Salesforce deployment and testing practices because catalog mistakes propagate into pricing, approvals, and downstream integrations.702installs34Sf Vlocity Build Deploysf-vlocity-build-deploy is an agent skill for Salesforce teams shipping OmniStudio and Vlocity artifacts using the official Vlocity Build CLI model. It walks solo builders and small implementation crews through job-file setup—projectPath, expansionPath vlocity, manifest entries, defaultMaxParallel, and header-only support—then the operational sequence: local validation, deploy, diff inspection, retry, and continue after failures. The skill credits the vlocityinc/vlocity_build repository and mirrors orchestration style from companion sf-deploy material so agents produce consistent deployment reports rather than one-off shell guesses. Use when a DataPack bundle (such as a Product2 UUID manifest) must land in an org with traceable planning and triage. Complexity is intermediate because you need Salesforce metadata context, Vlocity folder layout, and comfort reading build logs. It is not a generic Heroku deploy skill; it is narrowly tuned to Vlocity pack commands and documented example transcripts under sf-vlocity-build-deploy/examples.700installs