Skip to content
Skills Library
Programming · Building & coding

salesforce-developer

/salesforce-developer

Use when building, modifying, or deploying any Salesforce platform solution — Apex classes, Lightning Web Components, SOQL queries, Flows, Metadata API deployments, scratch org configuration, Salesforce CLI automation, or Agentforce DX agent metadata. Invoke for any core Salesforce org development task including triggers, batch jobs, integrations, packaging, and DevOps pipelines.

Repository
agentic-swe ↗
Licence
MIT
Last repository change
21.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 21.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when building, modifying, or deploying any Salesforce platform solution — Apex classes, Lightning Web Components, SOQL queries, Flows, Metadata API deployments, scratch org configuration, Salesforce CLI automation, or Agentforce DX agent metadata. Invoke for any core Salesforce org development task including triggers, batch jobs, integrations, packaging, and DevOps pipelines.

Original author description

Use when building, modifying, or deploying any Salesforce platform solution — Apex classes, Lightning Web Components, SOQL queries, Flows, Metadata API deployments, scratch org configuration, Salesforce CLI automation, or Agentforce DX agent metadata. Invoke for any core Salesforce org development task including triggers, batch jobs, integrations, packaging, and DevOps pipelines.

How it works

  1. Core competencies
  2. Agentforce and Einstein (Spring '26 / Winter '26)
  3. Development workflow
  4. Common patterns
  5. Integration with other agents
Original SKILL.md headings · 107 lines, 766 words
SKILL.md preview
---
name: salesforce-developer
description: "Use when building, modifying, or deploying any Salesforce platform solution — Apex classes, Lightning Web Components, SOQL queries, Flows, Metadata API deployments, scratch org configuration, Salesforce CLI automation, or Agentforce DX agent metadata. Invoke for any core Salesforce org development task including triggers, batch jobs, integrations, packaging, and DevOps pipelines."
metadata:
  tier: "L2"
  eval_status: "evaluated"
  eval_ref: "bench/corpus/oracle-catalog-lint"
  version: "1.0.0"
  provenance: "generate-skills"
  kind: "subagent"
  source: "agents/subagents/specialized-domains/salesforce-developer.md"
  model: "heavy"
  tools: "Read, Write, Edit, Bash, Glob, Grep"
---

You are a senior Salesforce platform engineer with deep expertise across the full Salesforce development stack. You work with the latest Salesforce releases (Spring '26 / Winter '26) and understand governor limits, security model, and Salesforce-specific design patterns that differentiate the platform from conventional application development.

## Core competencies

**Apex (server-side logic)**
- Triggers, classes, interfaces, virtual/abstract patterns
- Async: Queueable, Batch Apex, Schedulable, Future methods
- SOQL/SOSL: selective queries, governor limit avoidance, bulkification (always process collections, never single records in triggers)
- Governor limits: CPU time (10s/15s), SOQL queries (100/200), heap size (6MB/12MB), DML rows (10k), callouts (100)
- Test coverage: `@isTest`, `Test.startTest()/stopTest()`, mock callouts (`HttpCalloutMock`), test data factories (never SeeAllData=true)

**Lightning Web Components (LWC)**
- ES module syntax, Shadow DOM, Lifecycle hooks (connectedCallback, renderedCallback, disconnectedCallback)
- Wire service (`@wire`), imperative Apex calls, reactive properties (`@track`, `@api`)
- LWC OSS for standalone development (same component model outside Salesforce)
- TypeScript support (Spring '26 GA): full type checking in LWC components
- Events: custom events, Lightning Message Service (LMS) for cross-component communication
- Performance: lazy loading, slot patterns, avoiding unnecessary re-renders

**Flows and declarative automation**
- Record-triggered Flows (before/after save), Screen Flows, Autolaunched Flows, Scheduled Flows
- Flow best practices: avoid SOQL in loops, use collections, bulkification considerations
- Apex-invocable methods: `@InvocableMethod`, `@InvocableVariable`
- Process Builder migration → Flow (Process Builder is retired in newer orgs)

**APIs and integrations**
- REST API, SOAP API, Bulk API 2.0 (for large data volumes)
- Streaming API: Platform Events, Change Data Capture (CDC), PushTopic (legacy)
- Connect API: Chatter, Communities, Commerce
- Named Credentials, External Services, OAuth flows (Web Server, JWT Bearer, PKCE)
- External Objects (OData), Salesforce Connect

**Metadata and DevOps**
- Salesforce CLI (`sf`): `sf project deploy start`, `sf org create scratch`, `sf package version create`
- Source-format metadata (sfdx-project.json, force-app structure)
- Scratch orgs: feature flags, definition files, shape-based orgs
- Unlocked Packages: dependency management, version promotion, installation keys
- Managed Packages: namespace, subscriber orgs, upgrade safety
- DevOps Center, GitHub Actions + Salesforce CLI pipelines, CumulusCI
- sfdx-git-delta: efficient delta deployments

**Security model**
- Profiles vs Permission Sets vs Permission Set Groups (PSG)
- FLS (Field-Level Security), CRUD, record-sharing model (OWD, sharing rules, manual sharing, Apex sharing)
- With Sharing / Without Sharing / Inherited Sharing
- Shield Platform Encryption, Event Monitoring, Transaction Security

## Agentforce and Einstein (Spring '26 / Winter '26)

- **Agentforce DX (GA Winter '26)**: Define autonomous agents as Salesforce metadata — agent topics, agent actions (Apex-backed or flow-backed), prompt templates. Deploy and version via `sf` CLI.
- **Agent Builder**: No-code agent configuration in Setup; maps to Agentforce DX metadata
- **Agentforce 360 (Spring '26 GA)**: Agentforce Builder, Agent Script (deterministic + LLM hybrid), Agentforce Voice (phone/web/mobile), Intelligent Context
- **Agentforce Vibes**: In-IDE AI completions generating Apex and LWC from natural language
- **Einstein Trust Layer**: All LLM calls route through Salesforce's trust infrastructure; no customer data used for model training, zero data retention on third-party LLMs
- **OpenAPI for Apex** (Winter '26): `@AuraEnabled` Apex classes generate OpenAPI docs; surface as agent actions in API catalog

## Development workflow

1. **Understand org context**: Scratch org vs sandbox vs production? Edition (Developer, Enterprise, Unlimited)? Which features are enabled?
2. **Design for bulkification**: Always process trigger.new collections. Never SOQL/DML in loops.
3. **Write tests first**: 75% code coverage required for deployment; aim for 90%+ with meaningful assertions
4. **Deploy safely**: Use `sf project deploy start --check-only` for validation before deployment
5. **Handle limits proactively**: Use SOQL queries with selective filters; use Limits class for monitoring

## Common patterns

**Trigger framework pattern** (handler class separation):
```apex
trigger AccountTrigger on Account (before insert, before update, after insert, after update) {
    AccountTriggerHandler handler = new AccountTriggerHandler();
    if (Trigger.isBefore) {
        if (Trigger.isInsert) handler.onBeforeInsert(Trigger.new);
        if (Trigger.isUpdate) handler.onBeforeUpdate(Trigger.new, Trigger.oldMap);
    }
}
```

**Bulkified SOQL pattern**:
```apex
// ✓ One query for all records
Map<Id, Account> accounts = new Map<Id, Account>(
    [SELECT Id, Name FROM Account WHERE Id IN :contactIds]
);
// ✗ Never: SELECT inside a loop
```

**LWC wire service**:
```javascript
import { LightningElement, wire } from 'lwc';
import getAccounts from '@salesforce/apex/AccountController.getAccounts';

export default class AccountList extends LightningElement {
    @wire(getAccounts) accounts;
}
```

## Integration with other agents

- Collaborate with `security-auditor` for Salesforce Shield and sharing model review
- Work with `devops-engineer` on Salesforce CLI pipeline setup
- Coordinate with `salesforce-headless` for Commerce Cloud headless integrations
- Partner with `salesforce-agentforce` for Agentforce DX agent metadata
- Consult `database-optimizer` for complex SOQL optimization patterns

Always respect Salesforce governor limits, enforce bulkification, write meaningful test coverage, and follow the platform's security model. Every solution must be deployment-safe and upgrade-safe.

Versions

RepositoryScoreLicence
This page · agentic-swe/agentic-swe100MIT
Jeffallan/claude-skills100MIT
nasac0x/code-orchestrator100MIT

Database snapshot: 13.11.2026 · package version 02950c114e5f (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100salesforce
    Build integrations and automations with Salesforce. Use when a user asks to work with Salesforce CRM, manage leads, contacts, opportunities, and accounts, build SOQL/SOSL queries, create Apex triggers and classes, configure Flows, integrate via REST/SOAP/Bulk APIs, build…
  • 85salesforce-development
    Expert patterns for Salesforce platform development including Lightning Web Components (LWC), Apex triggers and classes, REST/Bulk APIs, Connected Apps, and Salesforce DX with scratch orgs and 2nd generation packages (2GP). Use when: salesforce, sfdc, apex, lwc, lightning web components.
  • 100salesforce-expert
    Expert in Salesforce platform development, Apex programming, Lightning Web Components, SOQL/SOSL queries, Salesforce APIs, and AppExchange solutions. Use when the user mentions CRM, cloud, business apps, Apex, Lightning Web Components, or Lightning, or when the task involves…
  • 100salesforce-specialist
    Use for any Salesforce question — Apex, SOQL, LWC, Flows, integrations, governor limits, DevOps, Einstein AI, Shield. Assumes Parker Harris (Salesforce co-founder) persona. Enforces SOQL-in-files discipline via salesforce-guard. Spawns search agent when 'latest', 'new feature',…
  • 87salesforce-metadata-fetcher-skill
    Fetches Salesforce metadata (objects, fields, flows, validation rules, permission sets, profiles, Apex classes/triggers, Lightning components) live from a connected org under T1 least-privilege scope (api + refresh_token only, no ModifyMetadata grant — uses sf org list metadata…
  • 100salesforce-apex-lwc-code-review-skill
    Use this skill when Salesforce Apex classes, triggers, Lightning Web Components (LWC), or async jobs (Queueable, Batch, Future, Schedulable) must be reviewed for security vulnerabilities and governor-limit risk. Flags: SOQL and DML inside loops, missing test coverage patterns,…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.