claude-sfdx-iq

Deep analysis of Salesforce code — answer questions about behavior, logic, and data flow

Generate ApexDoc documentation for Apex classes

Apex code quality review with severity ratings

Diagnose and fix deployment or compilation errors

Full code review across all Salesforce domains

Show loaded context or browse available skills and rules

Create and configure a scratch org for development

Show available claude-sfdx-iq commands and usage help

Analyze or design Salesforce data model with relationship mapping

Create and load sample data into a Salesforce org

Retrieve and analyze Salesforce debug logs

Source deploy with validation, org confirmation, and tests

Deploy destructive changes to remove metadata from an org

Generate and deploy destructive changes to remove metadata

Diagnose environment configuration for Salesforce development (alternative to npx claude-sfdx-iq doctor)

Explain Salesforce error with root cause and fix steps

Explain what a Salesforce code artifact does — LWC components, Apex classes, triggers, Flows

Flow best practices review for automation metadata

Governor limit risk analysis for Apex code

Install plugin components from a profile or manifest (alternative to npx claude-sfdx-iq install)

Run integration tests against a connected Salesforce org

List installed plugin components by category (alternative to npx claude-sfdx-iq list)

LWC component review for best practices and performance

Run LWC Jest tests with coverage reporting

Analyze metadata dependencies and deployment risks

Compare metadata between orgs, branches, or local and remote

Modify existing Salesforce code — add features, change behavior, add field logic, extend functionality

Org health check across security, limits, coverage, and technical debt

Create a second-generation package version

Manage second-generation (2GP) package versions

Interactively select components for a custom manifest (alternative to npx claude-sfdx-iq pick)

Create an implementation plan for a Salesforce feature

Run PMD static analysis on Apex code

Push source to a scratch org or sandbox

Regenerate project CLAUDE.md from template and profile (alternative to npx claude-sfdx-iq refresh)

Fix broken plugin configuration and missing files (alternative to npx claude-sfdx-iq repair)

Retrieve metadata from org to local source

Generate an Apex class with matching test class

Generate Apex class with matching test class by pattern type

Generate Batch Apex boilerplate with scheduler and test class

Generate Flow design document and implementation blueprint

Generate integration boilerplate with callout service, mock, and test

Generate LWC component with template, styles, config, and test

Generate trigger and handler boilerplate with test class

Create and configure a scratch org with source push and setup

Security vulnerability scan for CRUD/FLS, sharing, and injection

Set up an SFDX project with claude-sfdx-iq rules and configuration (alternative to npx claude-sfdx-iq setup-project)

Salesforce CLI command reference and recommendation

Analyze SOQL queries for optimization opportunities

SOQL query optimization and best practices review

Show plugin and Salesforce org status (alternative to npx claude-sfdx-iq status)

Start TDD workflow for Apex or LWC development

Generate TestDataFactory class for Apex tests

Run Apex tests with coverage analysis

Show token budget for installed components (alternative to npx claude-sfdx-iq tokens)

Validate deployment without deploying

Use this agent for Salesforce admin configuration guidance including permission set design, sharing rules, validation rules, custom metadata for configuration, custom labels, approval processes, email templates, and report type configuration.

Use this agent to review Apex code (classes, triggers, batch jobs, schedulable, queueable) for best practices, governor limit risks, bulkification issues, naming conventions, and code quality. Produces a structured review with severity levels.

Use this agent for Salesforce solution architecture decisions including data model design, integration architecture, scalability planning, packaging strategy, and declarative-vs-code decisions. Best for greenfield projects, major refactors, or when evaluating technical approaches.

Analyzes user requests and recommends which skills and rules to load. Returns a structured recommendation — does not load files directly.

Use this agent for Salesforce data model design including object relationships, record types, external IDs, polymorphic lookups, junction objects, formula optimization, rollup summaries, and data volume strategies (archival, big objects).

Use this agent for Salesforce deployment tasks including source deployments, package version creation, destructive changes, scratch org management, deployment troubleshooting, and CI/CD pipeline configuration.

Use this agent to analyze Salesforce Flows for best practices including DML optimization, fault path coverage, before-save vs after-save patterns, subflow decomposition, variable naming, and recursion prevention.

Use this agent to analyze Apex code for governor limit risks. Scans for SOQL/DML in loops, CPU-intensive operations, unbounded collections, and provides a limits budget estimation for transaction contexts.

Use this agent for Salesforce integration patterns including Named Credentials, REST/SOAP callouts, Platform Events, Change Data Capture, async callout patterns, retry with exponential backoff, and circuit breaker implementation.

Use this agent to review Lightning Web Components for best practices including proper decorator usage, lifecycle hooks, event handling, accessibility, CSS patterns, import conventions, and component composition.

Use this agent to analyze Salesforce metadata for dependencies, unused components, package organization, naming conventions, custom metadata vs custom settings decisions, and technical debt identification.

Use this agent when you need to plan a Salesforce feature implementation, break down complex requirements into phases, or create an implementation roadmap. Ideal for new features, large refactors, or multi-component changes that span metadata, Apex, LWC, testing, and deployment.

Use this agent to review Salesforce code and configuration for security vulnerabilities including CRUD/FLS enforcement, sharing model compliance, SOQL injection, CSP compliance, Connected App security, and Experience Cloud guest user risks.

Use this agent to analyze and optimize SOQL and SOSL queries for performance, selectivity, and governor limit compliance. Detects N+1 patterns, missing LIMIT clauses, non-selective filters, and provides query plan analysis recommendations.

Use this agent for Salesforce test-driven development guidance. Enforces test-first development for Apex, TestDataFactory patterns, proper test isolation, mock patterns for callouts, and LWC Jest testing. Targets 90%+ code coverage.

Future methods, Queueable, Batch Apex, and Schedulable patterns with chaining and governor limit strategies

Naming conventions, documentation standards, code structure rules, and PMD compliance for Apex

fflib enterprise patterns including Application factory, UnitOfWork, Selector base, Domain base, and Service layer

Enterprise design patterns for Apex including Service, Selector, Domain, Factory, and Strategy patterns

Apex test class patterns, TestDataFactory, assertion methods, and coverage strategies

Aura component architecture, events, server communication, and Aura-to-LWC migration strategies

Change Data Capture configuration, ChangeEvent triggers, replay strategies, and subscriber patterns

GitHub Actions workflows for SFDX, JWT auth, scratch org CI, test execution, code coverage gates, and artifact management

PMD for Apex, Salesforce Code Analyzer, cyclomatic complexity, custom rulesets, and CI integration

Master-Detail vs Lookup, junction objects, external IDs, record types, big objects, data skew prevention

Org-based vs package-based development models, sandbox strategies, Quick Deploy, and rollback planning

Custom exceptions, try-catch patterns, Database.SaveResult handling, error aggregation, and Platform Event logging

Experience Cloud site configuration, LWC in communities, guest user security, and deployment strategies

Flow design best practices including entry conditions, fault paths, bulkification, and naming conventions

When and how to convert Flows to Apex, migration patterns, hybrid approaches, and Invocable methods

Complete governor limits reference, Limits class usage, budgeting techniques, and async offloading strategies

Salesforce integration patterns including REST/SOAP callouts, Named Credentials, retry logic, and async integration

Custom logging framework with Platform Events, log levels, structured format, and retention management

LWC component patterns including wire service, events, navigation, composition, and record forms

LWC performance optimization including wire caching, lazy loading, DOM efficiency, and rendering best practices

LWC Jest testing patterns including wire adapters, DOM queries, event testing, and mocking

Metadata API types, source format, package.xml, deploy/retrieve commands, and destructive changes workflow

Org health monitoring, Security Health Check score, limits analysis, technical debt scoring, and automated health scripts

Second-generation package creation, versioning, ancestry, namespace management, and ISV distribution

Salesforce permission model including Permission Sets, sharing rules, OWD, custom permissions, and Apex managed sharing

Platform Event definition, publishing, subscribing, replay, and event-driven architecture patterns

Salesforce REST API patterns including custom endpoints, Composite API, Bulk API 2.0, and authentication

sfdx-project.json configuration, SF CLI commands, source tracking, alias management, and .forceignore patterns

Scratch org definition, creation, source push/pull, data seeding, org shapes, snapshots, and pooling strategies

CRUD/FLS enforcement, sharing keywords, security-enforced SOQL, permission checks, and credential management

Salesforce Shield Platform Encryption setup, key management, encrypted field limitations, and Apex Crypto class usage

SOQL query optimization including query plans, selective filters, indexing, and bulk query patterns

SOSL search patterns including FIND syntax, RETURNING clauses, search groups, and SOSL vs SOQL decisions

Test-Driven Development workflow for Apex and LWC using Red-Green-Refactor cycle

TriggerHandler base class, one-trigger-per-object pattern, recursion prevention, and execution order

Visualforce page patterns, controllers, ViewState management, and VF-to-LWC migration strategies

8 hooks across 2 events