salesforce-claude-code: Skill for Claude Code

Apex Best Practices

Procedures for writing production-ready Apex. Constraint rules (never/always lists) live in sf-apex-constraints. This skill covers the how — class organization, error handling patterns, null safety techniques, and collection usage.

Reference files:

@../_reference/GOVERNOR_LIMITS.md @../_reference/NAMING_CONVENTIONS.md @../_reference/SECURITY_PATTERNS.md

---

When to Use

• When writing new Apex classes, triggers, or test classes for a Salesforce org
• When reviewing existing Apex code for structure or error handling issues
• When onboarding new developers to Salesforce Apex coding standards
• When refactoring legacy Apex code to improve readability and maintainability

---

Class Organization

Organize class members in this order:

1. Constants (static final)
2. Static variables
3. Instance variables (fields)
4. Constructors
5. Public methods
6. Private/Protected methods
7. Inner classes

public with sharing class OrderProcessor {

    // 1. Constants
    private static final String STATUS_PENDING    = 'Pending';
    private static final String STATUS_PROCESSING = 'Processing';
    private static final String STATUS_COMPLETE   = 'Complete';
    private static final Integer MAX_LINE_ITEMS   = 500;

    // 2. Static variables
    private static Boolean isProcessing = false;

    // 3. Instance variables
    private List<Order__c> orders;
    private Map<Id, Account> accountMap;
    private OrderValidator validator;

    // 4. Constructor
    public OrderProcessor(List<Order__c> orders) {
        this.orders      = orders;
        this.accountMap  = new Map<Id, Account>();
        this.validator   = new OrderValidator();
    }

    // 5. Public methods
    public List<ProcessResult> processAll() {
        List<ProcessResult> results = new List<ProcessResult>();
        loadRelatedAccounts();
        for (Order__c order : orders) {
            results.add(processSingleOrder(order));
        }
        return results;
    }

    // 6. Private methods
    private void loadRelatedAccounts() {
        Set<Id> accountIds = new Set<Id>();
        for (Order__c order : orders) {
            if (order.AccountId != null) {
                accountIds.add(order.AccountId);
            }
        }
        for (Account acc : [SELECT Id, Name, CreditLimit__c FROM Account WHERE Id IN :accountIds]) {
            accountMap.put(acc.Id, acc);
        }
    }

    private ProcessResult processSingleOrder(Order__c order) {
        if (!validator.isValid(order)) {
            return new ProcessResult(order.Id, false, validator.getLastError());
        }
        order.Status__c = STATUS_PROCESSING;
        return new ProcessResult(order.Id, true, null);
    }

    // 7. Inner classes
    public class ProcessResult {
        public Id orderId     { get; private set; }
        public Boolean success { get; private set; }
        public String message  { get; private set; }

        public ProcessResult(Id orderId, Boolean success, String message) {
            this.orderId = orderId;
            this.success = success;
            this.message  = message;
        }
    }
}