Como usar IA para criar aplicativos na Solana

Desafios do desenvolvimento com IA na Solana

A arquitetura e os requisitos únicos da Solana podem causar problemas para a IA. Se ela não os considerar, você perderá tempo depurando o código ou reescrevendo programas, o que anula o objetivo de usar IA para agilizar o desenvolvimento.

A arquitetura única da Solana

A Solana se diferencia de três formas principais:

1. Modelo baseado em contas

Muitas blockchains, como a Ethereum, vinculam os dados diretamente ao armazenamento interno de um contrato inteligente. Já o modelo de programação da Solana organiza tudo em torno de “contas”. Essas contas armazenam os dados, enquanto os “programas” — o equivalente da Solana aos contratos inteligentes — modificam e interagem com esses dados. 

Uma diferença importante é que, na Solana, tudo é uma conta, inclusive os próprios programas. Programas são apenas contas que armazenam dados executáveis, o que permite que processem instruções. A Ethereum, por outro lado, distingue contas de propriedade externa (EOAs), controladas por chaves privadas, de contratos inteligentes, que têm código e armazenamento interno próprios. 

Essa diferença fundamental pode causar mal-entendidos, principalmente ao escrever código para a Solana. Assim como ocorre com contratos inteligentes da Ethereum, desenvolvedores que não conhecem o modelo de contas podem supor incorretamente que um programa pode ser proprietário dos próprios dados. Essas suposições podem resultar em erros de execução ou vulnerabilidades de segurança ao implantar na Solana.

2. Program Derived Addresses (PDAs)

Um Program-Derived Address (PDA) é criado a partir do ID de um programa e de uma seed. Os PDAs permitem que os programas organizem contas sem exigir uma chave privada. No entanto, os modelos de IA podem não distinguir um endereço padrão de um PDA. Se esquecerem de processar as seeds ou verificar a propriedade, o PDA estará correto como código Rust, mas não como código da Solana.

3. Execução paralela

O runtime da Solana, Sealevel, permite processar transações em paralelo, ao contrário das blockchains tradicionais, que processam uma transação por vez. Isso funciona porque as transações especificam quais contas serão lidas e gravadas. Com essas informações, a Solana determina quais contas precisam ser bloqueadas e executa várias transações simultaneamente com segurança. 

A IA costuma interpretar esse modelo de forma incorreta. Ela pode presumir que as transações serão executadas em sequência, como na Ethereum Virtual Machine (EVM). Isso pode gerar código que não aproveita o paralelismo. Como o sistema de bloqueio baseado em contas da Solana é diferente da abordagem da EVM, a IA pode escrever código com desempenho ruim ou pouca escalabilidade.

Problemas comuns

Existem alguns problemas recorrentes que os desenvolvedores enfrentam ao usar IA para criar aplicativos na Solana:

1. Código incorreto

A IA pode fornecer funções que compilam em Rust, mas falham quando implantadas na Solana. Por exemplo, ferramentas de programação em dupla com IA podem ignorar signatários ou interpretar referências de contas de forma incorreta. O resultado? Bugs ou vulnerabilidades de segurança que você só identifica ao executar testes, transações reais ou uma auditoria de segurança completa.

2. Código abaixo do ideal

Mesmo que o código gerado por IA funcione, ele pode não estar otimizado para unidades de computação, pode tornar o processamento de transações mais lento ou introduzir gargalos ocultos. Imagine uma IA escrevendo uma função para atualizar contas uma de cada vez. Ela não percebe que a Solana pode processá-las simultaneamente quando a implementação é correta.

3. Depuração difícil

Os modelos de IA não conhecem sua estrutura de pastas nem sabem como você definiu seus tipos de dados personalizados, a menos que você informe isso. Portanto, eles podem propor soluções incompatíveis com sua configuração atual, e integrar essas soluções ao projeto pode se tornar uma dor de cabeça.

Use as ferramentas de IA da Helius para lançar aplicativos na Solana mais rápido

Como explicamos acima, usar IA para criar corretamente na Solana não é fácil. 

Para mudar isso, criamos um conjunto de ferramentas de IA para desenvolvedores da Solana que cuida das partes difíceis para você: direciona para as ferramentas certas, aplica práticas recomendadas e oferece ao seu agente de IA a base necessária para transformar um único prompt em um aplicativo pronto para produção.

Helius MCP Server

O Helius MCP Server foi criado com base no padrão aberto Model Context Protocol (MCP) da Anthropic e disponibiliza mais de 60 ferramentas estruturadas — incluindo getBalance, parseTransaction, getAssetsByOwner e createWebhook — para qualquer cliente compatível com MCP (Claude Desktop, Cursor, VS Code, Windsurf e outros).

Em vez de criar comandos curl brutos e analisar a saída JSON, os agentes fazem chamadas tipadas de ferramentas e recebem respostas estruturadas diretamente. Isso torna cada interação com a API mais rápida, confiável e muito menos sujeita a erros.

Você pode adicioná-lo ao Claude Code com um único comando:

claude mcp add helius npx helius-mcp@latest

Helius Skills

Ter acesso a mais de 60 ferramentas não é útil se um agente não souber usá-las.https://www.helius.dev/blog/helius-for-agents#helius-skills-the-brain

As Skills são conjuntos de instruções especializadas — prompts cuidadosamente elaborados com lógica de roteamento e arquivos de referência — que ensinam um agente a atuar como especialista em desenvolvimento na Solana.

Com uma skill carregada, o agente sabe que deve usar searchAssets em vez de getProgramAccounts para buscar NFTs, obter taxas de prioridade dinamicamente e encaminhar transações pelo Sender para alcançar as maiores taxas de inclusão. 

Lançamos quatro skills:

• Build – Desenvolvimento essencial na Solana com todas as APIs da Helius
• DFlow – Aplicativos de negociação que usam as APIs da DFlow
• Phantom – Criação de frontends para dApps com o Phantom Connect SDK
• SVM – Funcionamento interno e aprofundado do protocolo da Solana

As skills são independentes de modelo e funcionam com a OpenAI API, Claude API, Cursor Rules e instruções personalizadas do ChatGPT.

Para contribuir com uma skill, preencha este formulário.

Helius CLI

A Helius CLI é uma interface de linha de comando completa, com mais de 95 comandos para gerenciamento de contas, envio de transações, gerenciamento de webhooks, streaming em tempo real, staking, ZK Compression e muito mais. 

Você pode usá-la diretamente ou deixar seu agente controlá-la — todos os comandos oferecem saída --json e códigos de saída estruturados, facilitando a análise de respostas e o tratamento programático de erros pelos agentes.

Instale a Helius CLI assim:

npm install -g helius-cli

Helius Claude Code Plugin

O Claude Code Plugin reúne o Helius MCP, o DFlow MCP, as quatro skills e arquivos de referência detalhados de todos os produtos Helius em uma única instalação — sem configuração manual do MCP nem configuração separada das skills.

Veja como instalá-lo:

/plugin marketplace add helius-labs/core-ai
/plugin install helius@helius-labs

Depois da instalação, um único prompt como “Crie uma CLI de declaração fiscal para esta carteira” produz um aplicativo CLI completo, funcional e paginado — sem precisar de prompts intermediários.

Juntas, essas ferramentas dão aos agentes de IA acesso às ferramentas e ao conhecimento de domínio necessários para pular a fase de tentativa e erro e entregar código Solana correto e otimizado desde o primeiro prompt.

Dicas para desenvolver na Solana com IA

Siga estas recomendações para criar aplicativos na Solana usando IA:

1. Comece com um prompt sólido

Um prompt de sistema é como a descrição do cargo da IA. Ele informa a função da IA (por exemplo, “Você é especialista em programação na Solana usando Anchor...”) e define as regras que ela deve seguir.

Veja um exemplo típico, ligeiramente ampliado:

# You are an expert in Solana program development.
Specializing in building and deploying smart contracts using Rust and Anchor,
and integrating on-chain data with @solana/web3.js.

---

## General Guidelines
- Write secure, efficient, and maintainable code for Solana programs.
- Thoroughly test and audit all programs before deployment.

## Solana Program Development with Rust and Anchor
- Prioritize Rust's safety and performance.
- Use Anchor macros to simplify account management, error handling, and
  data serialization.
- Keep code modular and maintain a clear separation between logic and data.

## Security and Best Practices
- Enforce strict access controls--ensure only permitted signers can modify data.
- Use PDAs responsibly: validate seeds and ownership checks to prevent conflicts.

## Performance and Optimization
- Minimize transaction costs by bundling operations efficiently.
- Exploit parallelism--don't serialize steps unnecessarily.
- Regularly benchmark your code to spot and remove performance

Por que funciona

Um prompt de sistema bem escrito funciona como um projeto: ele alinha a IA à arquitetura da Solana. Isso garante que todas as respostas sejam precisas, seguras e adaptadas às suas necessidades.

1. Define o contexto certo: declarar que a IA é “especialista em Solana” garante que ela se concentre em recursos específicos da Solana, como PDAs, paralelismo e Anchor, em vez de fazer suposições genéricas sobre blockchains.
2. Produz código consistente: incluir práticas recomendadas, como controles de acesso rigorosos e execução paralela, orienta a IA a criar resultados seguros, confiáveis e previsíveis.
3. Evita erros comuns: destacar a segurança do Rust, as macros do Anchor e a serialização reduz erros. Isso poupa o tempo que você gastaria depurando e reescrevendo código.
4. Aproveita os pontos fortes da Solana: a IA deve aumentar a largura de banda e reduzir a latência. Isso otimizará o código para a alta capacidade de processamento e a eficiência da Solana.

2. Escreva prompts claros

Ao pedir que a IA gere código, a precisão é essencial. Quanto mais preciso você for, melhores serão os resultados. Compare estes exemplos:

Prompt ruim:

“Escreva uma função para inicializar uma conta.”

Esse prompt é vago demais. A IA não sabe qual é a linguagem de programação, o framework ou que o prompt se destina a código da Solana. Ela pode fornecer código genérico ou inútil.

Bom prompt:

“Escreva uma função em Rust, usando Anchor, para inicializar uma conta de token da Solana. Use um PDA derivado de uma seed. Valide o estado da conta e trate erros caso ela já esteja inicializada.”

Veja por que o bom prompt funciona:

Prompts claros ajudam a economizar tempo e esforço. Ao esclarecer os objetivos da IA, você evita ter de corrigir depois um código descuidado, confuso ou inadequado. Isso também reduz interpretações incorretas e torna o trabalho com IA mais eficaz. 

1. É claro e direto: ao citar Rust, Anchor e PDAs diretamente, você informa à IA exatamente quais ferramentas e recursos usar. Ela não precisará adivinhar nem incluir detalhes irrelevantes.
2. Concentra-se nas necessidades da Solana: mencionar um PDA indica à IA que ela deve incluir lógica específica da Solana. Sem isso, o código pode omitir etapas importantes, como derivar endereços com segurança.
3. Acrescenta profundidade quando necessário: as instruções de validação e tratamento de erros orientam a IA a ir além do básico. Isso ajuda a garantir que o código funcione em cenários reais.

Um bom prompt funciona como um mapa que orienta a IA e a ajuda a evitar obstáculos para alcançar seus objetivos.

3. Forneça o contexto adequado

A IA funciona melhor quando você fornece o contexto adequado. Muitas ferramentas permitem enviar código ou vincular arquivos. Isso ajuda a IA a entender seu projeto e criar soluções compatíveis com sua base de código. 

Mas não a sobrecarregue. Fornecer informações demais à IA, como uma base de código grande e completa, pode fazê-la alucinar ou produzir respostas irrelevantes. 

Em vez disso, concentre-se nas partes relevantes do código. Isso mantém a IA focada e melhora a qualidade das sugestões.

Por exemplo, imagine que seu aplicativo já tenha um arquivo que define uma estrutura de dados personalizada:

#[account]
pub struct TokenAccount {
    pub balance: u64,
    pub is_initialized: bool,
    // ... more fields
}

Se você enviar esse arquivo ou incluí-lo como parte da entrada, a IA poderá usar os nomes exatos dos seus campos (balance, is_initialized) no código gerado.

Ela também pode alinhar as sugestões à estrutura e às convenções do seu projeto.

Por que fornecer contexto funciona

1. Melhora a precisão: sem contexto, a IA pode adivinhar nomes de campos, introduzir alterações desnecessárias ou presumir tipos de dados incorretos. Por exemplo, ela pode chamar seu campo de saldo de amount ou usar um f64 em vez de um u64. Fornecer a struct real elimina essas suposições.
2. Mantém a consistência do código: quando a IA entende suas convenções de nomenclatura, ela produz código que se encaixa naturalmente no projeto. Isso evita o trabalho de renomear variáveis ou reformular código para seguir os padrões existentes.
3. Reduz o trabalho de integração: se a IA tiver acesso às estruturas das suas contas, poderá adaptar a saída para integrá-la diretamente. Assim, você evita situações em que o código gerado por IA exige grandes reescritas para se adequar à lógica existente.

Exemplo: como adicionar contexto para melhorar as respostas da IA

Sem o contexto adequado, um prompt como “Escreva uma função para atualizar o saldo da conta de token” pode fazer a IA gerar um código como este:

pub fn update_balance(ctx: Context<UpdateAccount>, amount: f64) -> Result<()> {
    let account = &mut ctx.accounts.token_account;
    account.amount += amount;
    Ok(())
}

Esse código tem dois problemas:

Primeiro, ele usa f64 para o valor em vez de u64. 

A Solana oferece suporte muito limitado à aritmética nativa de ponto flutuante. A abordagem preferida é usar aritmética de ponto fixo e dimensionar os números com base nas casas decimais utilizadas, evitando problemas de desempenho e compatibilidade.

Segundo, ele chama o campo de saldo de amount, o que não corresponde à sua struct. Isso pode causar confusão e bugs no futuro.

Agora, se você fornecer sua struct TokenAccount como contexto, a IA poderá gerar isto:

pub fn update_balance(ctx: Context<UpdateAccount>, amount: u64) -> Result<()> {
    let token_account = &mut ctx.accounts.token_account;
    token_account.balance += amount;
    Ok(())
}

Essa saída está muito mais alinhada ao seu projeto. 

No entanto, mesmo com essa melhoria, vale adicionar uma verificação de overflow à operação token_account.balance += amount para garantir que seu código seja robusto e seguro.

Como fornecer contexto

Siga estas etapas para fornecer o contexto adequado às suas ferramentas de IA:

1. Envie arquivos: se a ferramenta de IA permitir, envie suas definições de structs, esquemas de contas e outros arquivos do projeto.
2. Inclua código de referência nos prompts: copie e cole trechos relevantes nos prompts para que a IA possa usá-los como referência.
3. Descreva a estrutura: se não for possível enviar arquivos, descreva seus dados com clareza no prompt. Por exemplo: “Tenho uma struct chamada TokenAccount com os campos balance (u64) e is_initialized (bool).”

4. Aproveite o código existente

Você não precisa começar do zero todas as vezes. Muitas vezes, já existe um trecho de código que funciona, mas pode ser melhorado. A IA pode ajudar você a aprimorá-lo. Veja um exemplo:

Este é o código original:

pub fn create_token_account(ctx: Context<CreateAccount>) -> Result<()> {
    let token_account = &mut ctx.accounts.token_account;
    token_account.balance = 0;
    Ok(())
}

Esse código inicializa uma conta de token e define o saldo como zero. Ele é simples, mas não trata cenários como a atualização de uma conta existente ou a verificação de propriedade.

Seu prompt:

“Torne esta função mais robusta. Se a conta de token existir, adicione o valor ao saldo. Caso contrário, inicialize-a com um valor específico. Também garanta que o programa atual seja proprietário da conta.”

Este é o código gerado pela IA após o prompt:

pub fn create_or_update_token_account(
    ctx: Context<CreateAccount>,
    amount: u64
) -> Result<()> {
    let token_account = &mut ctx.accounts.token_account;

    // Check ownership
    if token_account.owner != ctx.program_id {
        return err!(ProgramError::IncorrectProgramId);
    }

    // Update or initialize
    if token_account.is_initialized {
        token_account.balance += amount;
    } else {
        token_account.balance = amount;
        token_account.is_initialized = true;
    }

    Ok(())
}

Por que funciona

1. Abrange cenários comuns: o novo código trata contas inicializadas e não inicializadas, tornando-o mais útil em aplicativos reais.
2. Adiciona validação de propriedade: isso impede alterações não autorizadas, pois o programa verifica se é proprietário da conta.
3. Torna a função mais inteligente: agora, a função pode atualizar o saldo em vez de redefini-lo como zero todas as vezes. Isso reduz a redundância e atende a casos de uso reais.
4. Economiza tempo: você não precisou reescrever toda a função. A IA ampliou o que você já tinha, acelerando a evolução de uma função básica para uma função robusta.

Como usar esta abordagem

Siga estas etapas para aplicar essa abordagem no futuro:

1. Comece com uma base funcional: identifique funções ou trechos que funcionam, mas podem ser melhores.
2. Seja específico no prompt: explique o que deseja melhorar, como adicionar verificações de erro, tratar casos extremos ou aprimorar a lógica.
3. Revise as sugestões da IA: analise a saída gerada para garantir que ela seja adequada ao projeto e siga as práticas recomendadas da Solana.
4. Repita conforme necessário: se a primeira saída não estiver perfeita, ajuste o prompt ou edite o código para se aproximar do objetivo.

5. Avance uma etapa de cada vez

Criar código passo a passo ajuda você a evitar erros e refinar o trabalho durante o processo. Em vez de tentar criar uma função complexa de uma só vez, divida-a em tarefas menores. Assim, fica mais fácil testar e melhorar cada parte antes de avançar.

Exemplo de fluxo de trabalho

Vamos começar com algo pequeno. Peça à IA uma função simples para calcular um Program Derived Address (PDA) usando uma seed.

Veja um exemplo de prompt:

“Escreva uma função Rust que calcule um PDA a partir de uma seed e de um ID de programa usando Anchor.”

Saída da IA:

 pub fn find_pda(seed: &[u8], program_id: &Pubkey) -> Pubkey {
    Pubkey::create_program_address(&[seed], program_id).unwrap()
}

Esse é um bom ponto de partida, mas ainda não está completo. Vamos adicionar tratamento de erros.

Revise o código e identifique problemas. Por exemplo, usar unwrap() pode fazer o programa falhar se a seed for inválida.

Peça à IA que corrija isso:

“Atualize esta função para incluir o tratamento de erros de seeds inválidas. Retorne um Result em vez de usar unwrap.”

Código atualizado:

 pub fn find_pda(seed: &[u8], program_id: &Pubkey) -> Result<Pubkey, ProgramError> {
    Pubkey::create_program_address(&[seed], program_id)
        .map_err(|_| ProgramError::InvalidSeeds)
}

Agora, a função trata seeds inválidas de forma adequada, retornando um erro em vez de causar um panic.

Em seguida, vamos integrar a função. 

Peça à IA que use a função de PDA em uma rotina maior. Por exemplo:

“Escreva uma função que use este PDA para criar uma nova conta de token. Valide se o PDA ainda não está em uso.”

Esta é a saída da IA:

pub fn create_token_account(ctx: Context<CreateAccount>, seed: &[u8], amount: u64) -> Result<()> {
    let program_id = ctx.program_id;
    let pda = find_pda(seed, &program_id)?;

    if ctx.accounts.token_account.key != pda {
        return Err(ProgramError::InvalidSeeds);
    }

    if !ctx.accounts.token_account.is_initialized {
        let token_account = &mut ctx.accounts.token_account;
        token_account.balance = amount;
        token_account.is_initialized = true;
    }

    Ok(())
}

Essa etapa integra a lógica do PDA à criação da conta e garante que o PDA não seja reutilizado de forma incorreta.

Agora, vamos otimizar e finalizar o código. Peça à IA que refine ainda mais a função com um prompt como:

“Otimize esta função para minimizar os custos de transação e inclua a validação de propriedade.”

Esta é a saída da IA:

pub fn create_token_account(ctx: Context<CreateAccount>, seed: &[u8], amount: u64) -> Result<()> {
    let program_id = ctx.program_id;
    let pda = find_pda(seed, &program_id)?;

    if ctx.accounts.token_account.key != pda || ctx.accounts.token_account.owner != program_id {
        return Err(ProgramError::IncorrectProgramId);
    }

    if !ctx.accounts.token_account.is_initialized {
        let token_account = &mut ctx.accounts.token_account;
        token_account.balance = amount;
        token_account.is_initialized = true;
    }

    Ok(())
}

Agora, a função final é eficiente, segura e alinhada às práticas recomendadas da Solana.

Por que esta abordagem funciona

1. Mantém o trabalho gerenciável: concentrar-se em uma pequena tarefa por vez evita sobrecarregar a IA. Cada etapa se baseia na anterior, facilitando os testes e o refinamento.
2. Detecta erros cedo: etapas menores permitem identificar problemas antes que afetem o restante do código. Por exemplo, adicionar o tratamento de erros desde o início evita falhas posteriores.
3. Promove a iteração: se algo não funcionar perfeitamente, você poderá ajustar a função sem refazer toda a base de código.
4. Produz código melhor: cada refinamento torna o código mais robusto, resultando em uma solução mais confiável e fácil de manter.

Como usar esta abordagem

Lembre-se destas dicas na próxima vez que programar em dupla com uma IA:

1. Divida as tarefas em etapas menores: em vez de solicitar uma única função complexa, divida-a em tarefas mais simples e gerenciáveis e execute-as uma após a outra.
2. Teste os resultados após cada etapa: execute o código após cada alteração para confirmar que funciona. Caso contrário, corrija o problema ou ajuste o prompt antes de avançar.
3. Refine durante o processo: não se limite a um único resultado. Peça à IA que otimize ou adicione recursos como validações, melhorias de desempenho ou tratamento de erros mais eficiente.

Conclusão

Usar IA para criar na Solana pode ser extremamente poderoso, desde que você adote uma abordagem cuidadosa e criteriosa. A arquitetura da Solana é diferente da de outras blockchains, pois usa PDAs, processamento paralelo de transações e um design baseado em contas. Isso significa que você precisa orientar a IA corretamente.

Comece com prompts claros. Diga à IA exatamente o que deseja e especifique ferramentas como Rust, Anchor e PDAs. Um bom prompt poderia dizer:

“Escreva uma função Rust para inicializar uma conta de token da Solana com um PDA, validar o estado da conta e tratar erros.”

Essa clareza aumenta as chances de a IA produzir código que funcione na Solana.

Sempre forneça contexto. Compartilhe o código do projeto ou explique as estruturas utilizadas, como esquemas de contas ou tipos de dados. Por exemplo, se você tiver uma struct TokenAccount, inclua os detalhes para que a IA possa alinhar a saída. Mas não a sobrecarregue: concentre-se nas partes relevantes para manter as sugestões precisas e úteis.

Divida as tarefas em etapas menores. Use um processo iterativo para refinar o código ao longo do caminho. Comece com tarefas simples, como calcular um PDA, e depois acrescente tratamento de erros ou validação de contas. Teste após cada etapa. Assim, você identifica problemas cedo e avança de forma consistente.

Por fim, revise cuidadosamente o trabalho da IA. Muitas vezes, o código gerado por IA também apresenta pequenos problemas, como ausência de verificações de overflow ou validações ignoradas. Garanta que a saída siga as regras da Solana, não tenha bugs e use os recursos de execução paralela.

A IA é apenas o ponto de partida; você precisa concluir o trabalho. Com instruções claras, contexto, desenvolvimento passo a passo e revisão cuidadosa, você pode usar IA para criar programas Solana seguros e otimizados. Continue participando do processo, e a IA se tornará uma ferramenta valiosa para economizar tempo e escrever códigos melhores.

Leituras adicionais

Para saber mais sobre como criar com IA na Solana, consulte estes recursos:

1. Anthropic: visão geral da engenharia de prompts
2. AWS: técnicas de engenharia de prompts
3. Como otimizar programas Solana
4. Como otimizar o uso de computação na Solana
5. Documentação do Anchor