Salesforce Claude Code (SCC)

The complete AI development system for Salesforce — expert agents, automated quality gates, and institutional knowledge, powered by @salesforce/mcp

SCC (scc-universal on npm) is a Claude Code plugin that supercharges your Salesforce development workflow with 17 expert subagents, 55 domain knowledge skills, and 29 automated quality gates. Built for Apex, LWC, SOQL, Flow, Visualforce, Aura, DevOps, and Agentforce — covering every layer of the Salesforce platform.

How It Works

SCC is a unified system where each layer serves a distinct role:

Together: @salesforce/mcp gives Claude the hands to work with Salesforce. SCC gives Claude the brain to work well.

What's Included

Requirements

• Node.js >= 20 — required to run the npx scc-universal CLI
• Python 3.x — required for learning-engine agent (instinct CLI)

Quick Install

For Claude Code

# Install everything (agents → .claude/agents/, skills → .claude/skills/, hooks → .claude/settings.json)
npx scc-universal install

# Install only Apex-focused content
npx scc-universal install apex

# Install only LWC-focused content
npx scc-universal install lwc

For Cursor

# Install everything (agents → .cursor/agents/, skills → .cursor/skills/, hooks → .cursor/hooks.json)
npx scc-universal install --target cursor

# Install only Apex-focused content
npx scc-universal install apex --target cursor

Diagnose and Repair

npx scc-universal doctor       # Check for missing/drifted files
npx scc-universal repair       # Restore drifted files
npx scc-universal status       # View installed components
npx scc-universal uninstall    # Remove SCC-managed files

CLI Reference

Install flags:

What Gets Installed

Install Profiles

SCC content is organized into 7 modules. Profiles compose subsets:

Key Features

Apex Best Practices

• Bulkification patterns, governor limit awareness, and collections-first coding
• Trigger handler framework integration (FFLIB Enterprise Patterns + pragmatic single-trigger)
• Async Apex: Queueable, Batch, Schedulable design patterns
• Exception handling, custom exception hierarchies, and structured logging

LWC Patterns

• Component lifecycle management and reactive property wiring
• Base component usage, composition over inheritance
• Accessibility (ARIA) compliance and keyboard navigation
• Wire adapters, imperative Apex calls, and error boundary patterns

SOQL Optimization

• Index-aware WHERE clause construction and selectivity guidance
• Avoiding full-table scans and non-selective filters
• Parent-child relationship queries and aggregate optimization
• SOQL in loops detection and bulk query strategies

Trigger Frameworks

• FFLIB-style trigger dispatcher and domain layer integration
• Pragmatic single-trigger-per-object with handler routing
• Recursive prevention patterns and context-aware execution
• TriggerOperation enum usage and before/after separation

Security — CRUD / FLS / Sharing

• Schema.SObjectField.getDescribe() for FLS checks
• WITH SECURITY_ENFORCED and stripInaccessible() usage
• Sharing model enforcement and without sharing justification
• SOQL injection prevention and safe dynamic queries

DevOps / CI-CD

• SF CLI v2 (sf) command patterns and project structure
• Scratch org creation, source push/pull, and org pooling
• Metadata API vs Source format understanding
• GitHub Actions / GitLab CI pipeline patterns for Salesforce

Agentforce AI Agents

• Agentforce Agent Builder configuration and topic definitions
• Custom action creation (Apex, Flow, prompt templates)
• Agent testing and conversation design patterns
• Einstein AI feature integration

Salesforce MCP Integration

SCC is designed to complement the official Salesforce MCP server. Install both for the full experience:

• @salesforce/mcp provides: org management, metadata deployment, SOQL queries, Apex test execution, code analysis, LWC tools, DevOps operations
• SCC provides: domain expertise to use those tools correctly, quality gates to catch mistakes, and institutional knowledge to follow best practices

MCP config is auto-installed by npx scc-universal install:

npx scc-universal install all --target claude   # Installs .mcp.json at project root
npx scc-universal install all --target cursor   # Installs .cursor/mcp.json

Enhanced Quality Gates

SCC integrates with Salesforce Code Analyzer for machine-enforceable checks:

# Install the scanner (one-time setup)
sf plugins install @salesforce/sfdx-scanner

Once installed, SCC automatically runs PMD analysis:

• Standard profile: Scanner runs before git push and sf project deploy
• Strict profile: Scanner runs on every code edit
• Graceful no-op if scanner is not installed — SCC falls back to regex-based checks

Cross-Harness Support

All content is structured for use across multiple AI harnesses:

• Claude Code — primary harness with full hook integration
• Cursor — rules, skills, and hooks exported to .cursor/ directory

Agents

Skills

Skills

17 skills are user-invocable via /skill-name. 38 are auto-activating context skills (28 pattern + 7 constraint + 3 platform).

User-Invocable (17)

Invoke with /skill-name in Claude Code or Cursor.

Pattern Skills (28) — Agent-Consulted

Agents read these on demand for domain knowledge. Not directly invocable via /.

Auto-Activating Skills

38 skills activate automatically during development — no / invocation needed.

Constraint Skills (always-on governance):

Platform Context Skills (3):

Pattern skills (28, listed above) also activate contextually when their domain is relevant.

Hook Profiles

Control which hooks run via the SCC_HOOK_PROFILE environment variable:

Environment Variables

Tips and Best Practices

Typical Workflows

New Feature: Describe what you want to build — sf-architect activates automatically, designs the solution, and delegates to domain agents (sf-apex-agent, sf-lwc-agent, sf-flow-agent) with TDD.

Bug Fix: Describe the error — sf-bugfix-agent activates, diagnoses root cause, applies minimal fix.

Code Review: Ask to review before deploy — sf-review-agent runs a full quality gate (security, governor limits, test coverage, deploy readiness).

Key Principles

1. Governor limits are king — Every agent checks for limit violations
2. Test-first approach — 75% is the SF minimum, aim for 85%+
3. Be specific — "Review AccountTrigger.cls" not "review everything"
4. Hook profiles matter — Start with standard, move to strict for CI
5. Security baked in — CRUD/FLS and sharing model from the start

Documentation

Example Patterns

Production-ready implementations demonstrating Salesforce best practices:

Contributing

Contributions are welcome! Please follow these guidelines:

1. Follow the existing file naming convention: lowercase with hyphens.
2. All agents must have valid YAML frontmatter (name, description, tools, model).
3. All skills must include a SKILL.md with name, description, and origin: SCC in frontmatter.
4. Run npm test before submitting a pull request — all CI validators must pass.
5. Use Conventional Commits format: <type>: <description> (max 100 chars).
6. Coverage must stay above 80% for lines, functions, branches, and statements.

git clone <repo>
cd salesforce-claude-code
npm install
git config core.hooksPath .githooks   # Enable pre-commit checks
npm test                               # Build + lint + validate + tests
bash scripts/ci/smoke-test.sh          # Pack + install/uninstall smoke test

License

MIT — see LICENSE for details.

Acknowledgements

SCC's plugin architecture was inspired by Everything Claude Code (ECC) by Affaan Mustafa, licensed under the MIT License. Since v1.0.0, SCC is independently maintained with its own roadmap, Salesforce-specific content, and infrastructure.