Como o plugin oficial da Salesforce para a CLI do Claude Code combina mais de 40 Agent Skills, servidores MCP embutidos e diagnósticos de linguagem em tempo real para transformar o terminal no seu ambiente de desenvolvimento primário.
Quantas vezes você já abriu o VS Code, esperou cinco minutos para os plugins de Salesforce terminarem de indexar metadados, viu a ventoinha do notebook disparar a 100% e percebeu que precisava de quatro gigabytes de memória RAM só para ajustar três linhas em um serviço de Apex?
Se você desenvolve na plataforma Salesforce há algum tempo, você conhece bem essa dor.
Durante anos, fomos condicionados a acreditar que desenvolvimento corporativo exige interfaces visuais pesadas. Passamos pelo Force.com IDE no Eclipse, sofremos com a lentidão do Developer Console web e nos acomodamos no VS Code com o Salesforce Extension Pack. Mas a engenharia de software de ponta está em outro lugar.
A maré virou: entramos de cabeça na era do Headless Development (desenvolvimento sem interface gráfica).
Com assistentes de inteligência artificial baseados em linha de comando — encabeçados pelo Claude Code CLI da Anthropic — e padrões universais de interoperabilidade como o Model Context Protocol (MCP), o terminal voltou a ser a ferramenta mais poderosa e rápida do programador.
E a Salesforce não ficou para trás: com o lançamento oficial do plugin salesforce-development@claude-plugins-official no marketplace do Claude Code, a plataforma ganha uma esteira agêntica completa direto no prompt. São mais de 40 skills homologadas do repositório sf-skills, três servidores MCP embutidos com o Language Server de Apex/SOQL rodando localmente no terminal (salesforce-lsp) e agentes dedicados a auditar código contra as diretrizes do Salesforce Well-Architected.
Neste artigo prático de engenharia de campo, vamos abrir essa caixa-preta: da instalação e validação das ferramentas até o deploy e execução empírica de código Apex na nossa org de testes conectada.
1. A tríade do desenvolvimento agêntico: Skills, MCP e Plugins
Para entender como essa engrenagem funciona sem interfaces visuais, precisamos separar três conceitos que muita gente confunde:
1. Agent Skills (Habilidades Agênticas)
Uma skill é uma instrução estruturada e versionável que ensina o modelo de linguagem a executar uma tarefa técnica rigorosa. Fisicamente, é uma pasta contendo um arquivo SKILL.md com metadados YAML e procedimentos cirúrgicos em Markdown. O segredo aqui é o lazy-loading: o agente de IA não lê os 40 arquivos de skills de uma vez. Ele carrega apenas os nomes e as descrições no início da sessão. Somente quando você pede uma tarefa específica (como criar um serviço Apex respeitando WITH USER_MODE) é que a skill correspondente entra na memória de trabalho.
2. Model Context Protocol (MCP)
Enquanto a skill é o conhecimento metodológico, os servidores MCP são os braços executivos. O MCP atua como um padrão universal aberto (JSON-RPC) que permite ao Claude interagir com ferramentas locais, bancos de dados, APIs e compiladores sem acoplamento proprietário.
3. Agent Plugins (A camada de distribuição)
Até pouco tempo, montar esse ambiente exigia clonar repositórios git na mão, editar arquivos claude.json e rezar para as variáveis de ambiente estarem alinhadas. O plugin oficial da Salesforce resolve esse gargalo: um único comando instala skills, inicializa servidores MCP e registra os agentes especializados no seu terminal.
2. A anatomia do plugin oficial salesforce-development
Ao rodar a instalação do plugin no Claude Code, a CLI passa a ter acesso a um ecossistema completo de ferramentas nativas:
A arquitetura distribui responsabilidades de forma modular:
- Catálogo de 40+ Skills (
forcedotcom/sf-skills): Templates e fluxos de trabalho homologados pela Salesforce cobrindo governança, DX, Apex, LWC, Data Cloud e Agentforce. - Servidores MCP embutidos:
salesforce-lsp: O trunfo técnico do pacote. Executa no terminal os mesmos Language Servers oficiais de Apex e SOQL do VS Code, acusando erros de sintaxe, tipos inválidos e referências quebradas de campos antes de qualquer deploy.salesforce-metadata-experts: Injeta inteligência profunda sobre tipos de metadados e dependências de pacotes.salesforce-api-context: Fornece limites da org, sessões ativas e metadados de Tooling e REST API em tempo real.
- Agentes Especializados:
salesforce-dev: O orquestrador central para geração e refatoração de código.architecture-review: Um auditor estrito que avalia o repositório contra os pilares Trusted, Easy e Adaptable do Salesforce Well-Architected.ADLC: Agentes focados no ciclo de vida de desenvolvimento do Agentforce e scripts.agent.
3. Preparando o ambiente no terminal
A configuração no terminal é direta e exige apenas as ferramentas de engenharia que todo time moderno já deveria ter instaladas:
Pré-requisitos de sistema:
- Node.js LTS (versões 22 ou 24).
- Salesforce CLI (
sf) devidamente instalada e atualizada. - Claude Code CLI instalada globalmente (
npm install -g @anthropic-ai/claude-code). - Python 3.8+ (utilizado internamente por analisadores de segurança e scripts auxiliares).
Passo 1: Autenticar a organização de desenvolvimento
Antes de abrir o assistente, garanta que sua org padrão esteja definida no workspace DX:
# Autentica via navegador e marca como org padrão do projeto
sf org login web --alias DevOrg --set-defaultPasso 2: Instalar o plugin oficial no Claude Code
Abra a CLI interativa do Claude Code digitando claude no terminal da raiz do projeto e instale a extensão oficial:
/plugin install salesforce-development@claude-plugins-officialPasso 3: Executar a validação de integridade
Após o download, rode o setup diagnóstico:
/salesforce-development:setupO comando valida a comunicação com o salesforce-lsp, confirma a acessibilidade da Salesforce CLI e checa o handshake com a organização conectada.
4. O fluxo prático na ponta dos dedos: do prompt ao deploy
Vamos ver o ambiente operando na prática com um caso de negócio real: a construção de um serviço corporativo de atribuição de contas por território com lógica de segurança estrita e cobertura total de testes.
No prompt do Claude Code, disparou-se a seguinte instrução em linguagem natural:
“Crie uma classe de serviço em Apex chamada AccountTerritoryService para atribuir o território ‘LATAM Enterprise’ a contas com faturamento anual acima de 50 milhões. Garanta respeito às regras de compartilhamento com USER_MODE, crie a respectiva classe de testes com 100% de cobertura e valide o deploy na minha org padrão.”
O que o Claude Code faz em segundos:
- Identifica a intenção e faz lazy-load da skill
platform-apex-generate. - Cria o arquivo
force-app/main/default/classes/AccountTerritoryService.cls. - O servidor MCP
salesforce-lspvalida se os camposAnnualRevenueeDescriptionexistem e têm tipos compatíveis no schema local. - Gera a suíte de testes
AccountTerritoryServiceTest.clsutilizandoAssert.areEquale dados isolados com@TestSetup. - Aciona a Salesforce CLI em segundo plano e realiza o deploy com relatório no terminal.
O código gerado e validado:
/*
* Data: 2026-09-25
* Objetivo da Customização: Serviço corporativo de atribuição de território de contas via Headless Development (Claude Code Salesforce Plugin)
*/
public with sharing class AccountTerritoryService {
public static final String TIER_LATAM_ENTERPRISE = 'LATAM Enterprise';
public static final Decimal REVENUE_THRESHOLD = 50000000;
/**
* Avalia e atribui o território qualificado para uma lista de IDs de contas.
* @param accountIds Lista de identificadores das contas a processar.
* @return Quantidade de registros que sofreram atualização de território.
*/
public static Integer assignEnterpriseTerritories(Set<Id> accountIds) {
if (accountIds == null || accountIds.isEmpty()) {
return 0;
}
List<Account> accountsToUpdate = new List<Account>();
// Consulta estrita com conformidade ao modelo de compartilhamento do usuário
List<Account> targetAccounts = [
SELECT Id, Name, AnnualRevenue, Description
FROM Account
WHERE Id IN :accountIds
AND AnnualRevenue >= :REVENUE_THRESHOLD
WITH USER_MODE
];
for (Account acc : targetAccounts) {
acc.Description = (acc.Description != null ? acc.Description + ' | ' : '') +
'Território Atribuído: ' + TIER_LATAM_ENTERPRISE;
accountsToUpdate.add(acc);
}
if (!accountsToUpdate.isEmpty()) {
update as user accountsToUpdate;
}
return accountsToUpdate.size();
}
}E a respectiva suíte de testes unitários:
/*
* Data: 2026-09-25
* Objetivo da Customização: Testes unitários para validação de AccountTerritoryService (Headless Development via Claude Code)
*/
@IsTest
private class AccountTerritoryServiceTest {
@TestSetup
static void makeData() {
List<Account> testAccs = new List<Account>{
new Account(Name = 'Enterprise Account', AnnualRevenue = 60000000),
new Account(Name = 'Standard Account', AnnualRevenue = 10000000)
};
insert as user testAccs;
}
@IsTest
static void testAssignEnterpriseTerritoriesSuccess() {
Map<Id, Account> accountsMap = new Map<Id, Account>([SELECT Id FROM Account]);
Test.startTest();
Integer updatedCount = AccountTerritoryService.assignEnterpriseTerritories(accountsMap.keySet());
Test.stopTest();
Assert.areEqual(1, updatedCount, 'Apenas a conta com faturamento acima de 50M deve ser atualizada.');
Account updatedAcc = [
SELECT Description
FROM Account
WHERE AnnualRevenue = 60000000
LIMIT 1
];
Assert.isTrue(
updatedAcc.Description.contains(AccountTerritoryService.TIER_LATAM_ENTERPRISE),
'O território empresarial deve constar na descrição da conta.'
);
}
@IsTest
static void testAssignEnterpriseTerritoriesNullOrEmpty() {
Test.startTest();
Integer zeroUpdated = AccountTerritoryService.assignEnterpriseTerritories(null);
Integer emptyUpdated = AccountTerritoryService.assignEnterpriseTerritories(new Set<Id>());
Test.stopTest();
Assert.areEqual(0, zeroUpdated, 'Conjunto nulo deve retornar 0.');
Assert.areEqual(0, emptyUpdated, 'Conjunto vazio deve retornar 0.');
}
}5. Evidências empíricas de execução na org conectada
Os resultados obtidos diretamente da org de testes atestam a qualidade da entrega:
=== Deploy Status
Status: Succeeded (Deploy ID: 0AfWs00001cuFpCKAU)
Deployed: AccountTerritoryService.cls, AccountTerritoryServiceTest.cls
=== Apex Test Run Summary (707Ws00001ZHM4c)
TEST NAME OUTCOME RUNTIME (MS)
────────────────────────────────────────────────────────────────────── ─────── ────────────
AccountTerritoryServiceTest.testAssignEnterpriseTerritoriesNullOrEmpty Pass 11
AccountTerritoryServiceTest.testAssignEnterpriseTerritoriesSuccess Pass 120
=== Apex Code Coverage: 100% (Pass Rate: 100%)
USER_DEBUG|[9]|DEBUG|CONTA_CRIADA_ID: 001Ws000064ljXfIAI
USER_DEBUG|[15]|DEBUG|TERRITORIOS_ATRIBUIDOS_COUNT: 1
USER_DEBUG|[19]|DEBUG|CONTA_DESCRICAO_FINAL: Cliente Corporativo Prioritario | Território Atribuído: LATAM EnterpriseExecução em 131 milissegundos. Zero consumo desnecessário de memória na máquina do desenvolvedor e 100% de cobertura de código.
6. Comparativo: IDE gráfica tradicional vs. Headless Development
| Dimensão de Análise | IDE Tradicional (VS Code + Extension Pack) | Headless com Claude Code Plugin |
|---|---|---|
| Interface de Trabalho | Janela gráfica com abas, painéis e consumo alto de GPU | Terminal puro (CLI) leve, focado e veloz |
| Consumo de Memória | Comum atingir 2 a 4 GB com múltiplos plugins abertos | Mínimo, executando em processos isolados e eficientes |
| Geração de Código | Depende de snippets estáticos ou digitação manual | Geração agêntica contextualizada pelo schema da org |
| Diagnóstico de Código | Language Server rodando acoplado à janela do editor | salesforce-lsp via MCP rodando direto no fluxo do agente |
| Auditoria Arquitetural | Depende de plugins externos ou revisão manual em PR | Nativa, acionada via agente architecture-review |
| Manipulação de Agentes | Edição de arquivos .agent em texto simples | Validação sintática contínua via hooks de Agent Script |
Para onde vai o desenvolvimento Salesforce?
O paradigma headless não significa aposentar o VS Code para sempre. A interface gráfica ainda tem seu valor para navegação exploratória e depuração visual de layouts complexos.
Mas para o trabalho pesado do dia a dia — criar serviços, refatorar triggers, escrever testes com dados isolados, validar contratos e rodar deploys —, o terminal com Claude Code e o plugin oficial da Salesforce é imbatível. A produtividade é de outra ordem de magnitude.
Se o seu fluxo de desenvolvimento ainda depende de cliques de mouse para tarefas que um assistente de terminal resolve em dois segundos com validação semântica de Language Server, é hora de repensar seu ambiente de engenharia. Instale o plugin, configure suas skills e experimente o poder do desenvolvimento agêntico na ponta dos dedos.