Cómo usar IA para crear aplicaciones en Solana

Desafíos del desarrollo con IA en Solana

La arquitectura y los requisitos únicos de Solana pueden causar problemas para la IA. Si la IA no los considera, perderás tiempo depurando el código o reescribiendo los programas. Esto anula el propósito de usar IA para agilizar el desarrollo.

La arquitectura única de Solana

Solana se distingue de tres formas principales:

1. Modelo basado en cuentas

Muchas blockchains, como Ethereum, vinculan los datos directamente con el almacenamiento interno de un contrato inteligente. En cambio, el modelo de programación de Solana organiza todo alrededor de «cuentas». Estas cuentas almacenan los datos, mientras que los «programas» —el equivalente de Solana a los contratos inteligentes— modifican esos datos e interactúan con ellos. 

Una diferencia clave es que, en Solana, todo es una cuenta, incluso los propios programas. Los programas son simplemente cuentas que almacenan datos ejecutables, lo que les permite procesar instrucciones. En cambio, Ethereum distingue entre cuentas de propiedad externa (EOA), controladas mediante claves privadas, y contratos inteligentes, que tienen su propio código y almacenamiento interno. 

Esta diferencia fundamental puede provocar malentendidos, sobre todo al escribir código para Solana. Al igual que ocurre con los contratos inteligentes de Ethereum, los desarrolladores que no conocen el modelo de cuentas podrían asumir erróneamente que un programa puede ser propietario de sus datos. Estas suposiciones pueden provocar errores de ejecución o vulnerabilidades de seguridad al implementar en Solana.

2. Direcciones derivadas de programas (PDA)

Una dirección derivada de un programa (PDA) se crea a partir del ID de un programa y una semilla. Las PDA permiten que los programas organicen cuentas sin necesitar una clave privada. Sin embargo, es posible que los modelos de IA no distingan entre una dirección estándar y una PDA. Si olvidan gestionar las semillas o verificar la propiedad, la PDA tendrá código Rust correcto, pero no será código correcto para Solana.

3. Ejecución en paralelo

El entorno de ejecución de Solana, Sealevel, permite procesar transacciones en paralelo, a diferencia de las blockchains tradicionales, que procesan las transacciones una por una. Esto funciona porque las transacciones especifican qué cuentas leerán y en cuáles escribirán. Con esta información, Solana puede determinar qué cuentas necesitan bloqueos y ejecutar muchas transacciones al mismo tiempo de forma segura. 

La IA suele interpretar mal este modelo. Puede asumir que las transacciones se ejecutarán de forma secuencial, como en la máquina virtual de Ethereum (EVM). Esto podría generar código que no aproveche el paralelismo. Como el sistema de bloqueo basado en cuentas de Solana difiere del enfoque de la EVM, la IA podría escribir código con un rendimiento deficiente o que no escale bien.

Problemas frecuentes

Los desarrolladores enfrentan varios problemas recurrentes al usar IA para crear aplicaciones en Solana:

1. Código incorrecto

La IA podría proporcionar funciones que compilan en Rust, pero fallan cuando las implementas en Solana. Por ejemplo, las herramientas de programación en pareja con IA podrían omitir firmantes o interpretar mal las referencias a cuentas. ¿El resultado? Errores o vulnerabilidades de seguridad que no puedes detectar hasta ejecutar pruebas o transacciones reales, o completar una auditoría de seguridad.

2. Código no optimizado

Incluso si el código generado por IA funciona, podría no estar optimizado para unidades de cómputo, ralentizar el procesamiento de transacciones o introducir cuellos de botella ocultos. Imagina que una IA escribe una función para actualizar cuentas una por una. No reconoce que Solana puede procesarlas simultáneamente si se implementan de forma correcta.

3. Depuración difícil

Los modelos de IA no conocen tu estructura de carpetas ni cómo definiste tus tipos de datos personalizados, a menos que se los indiques. Por eso, podrían proponer soluciones que entren en conflicto con tu configuración actual. Integrar esas soluciones de nuevo en tu proyecto puede convertirse en un dolor de cabeza.

Usa las herramientas de IA de Helius para lanzar aplicaciones en Solana más rápido

Como explicamos antes, usar IA para desarrollar correctamente en Solana no es fácil. 

Para cambiar esto, creamos un conjunto de herramientas de desarrollo con IA para Solana que se ocupa de las partes difíciles: dirigir las solicitudes a las herramientas adecuadas, aplicar prácticas recomendadas y proporcionar al agente de IA la base necesaria para pasar de un solo prompt a una aplicación lista para producción.

Helius MCP Server

Helius MCP Server se basa en el estándar abierto Model Context Protocol (MCP) de Anthropic y ofrece más de 60 herramientas estructuradas —incluidas getBalance, parseTransaction, getAssetsByOwner y createWebhook— a cualquier cliente compatible con MCP (Claude Desktop, Cursor, VS Code, Windsurf y otros).

En lugar de crear comandos curl sin procesar y analizar resultados JSON, los agentes realizan llamadas tipadas a herramientas y reciben respuestas estructuradas directamente. Esto hace que cada interacción con la API sea más rápida, confiable y mucho menos propensa a errores.

Puedes agregarlo a Claude Code con un solo comando:

claude mcp add helius npx helius-mcp@latest

Helius Skills

Tener acceso a más de 60 herramientas no sirve si un agente no sabe cómo usarlas.https://www.helius.dev/blog/helius-for-agents#helius-skills-the-brain

Las Skills son conjuntos de instrucciones especializadas —prompts cuidadosamente diseñados con lógica de enrutamiento y archivos de referencia— que enseñan a un agente a convertirse en un desarrollador experto en Solana.

Con una skill cargada, un agente sabe que debe usar searchAssets en lugar de getProgramAccounts para buscar NFT, obtener dinámicamente las comisiones de prioridad y dirigir las transacciones a través de Sender para lograr las tasas de inclusión más altas. 

Lanzamos cuatro skills:

• Build – Desarrollo principal en Solana con todas las API de Helius
• DFlow – Aplicaciones de trading que usan las API de DFlow
• Phantom – Creación de interfaces para dApps con Phantom Connect SDK
• SVM – Funcionamiento interno avanzado del protocolo de Solana

Las skills son independientes del modelo y funcionan con OpenAI API, Claude API, Cursor Rules y las instrucciones personalizadas de ChatGPT.

Para contribuir con una skill, completa este formulario.

Helius CLI

Helius CLI es una interfaz de línea de comandos completa con más de 95 comandos para administrar cuentas, enviar transacciones, gestionar webhooks, transmitir datos en tiempo real, hacer staking, usar ZK Compression y mucho más. 

Puedes usarla directamente o permitir que tu agente la controle. Todos los comandos admiten resultados --json y códigos de salida estructurados, lo que facilita que los agentes analicen respuestas y gestionen errores mediante programación.

Instala Helius CLI así:

npm install -g helius-cli

Helius Claude Code Plugin

Claude Code Plugin combina Helius MCP, DFlow MCP, las cuatro skills y archivos de referencia detallados para cada producto de Helius en una sola instalación. No requiere configurar MCP manualmente ni instalar cada skill por separado.

Así puedes instalarlo:

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

Una vez instalado, un solo prompt como «Crea una CLI para generar informes fiscales de esta billetera» produce una aplicación CLI paginada y totalmente funcional, sin necesidad de prompts intermedios.

En conjunto, estas herramientas brindan a los agentes de IA las herramientas y el conocimiento especializado necesarios para omitir la fase de prueba y error y generar código de Solana correcto y optimizado desde el primer prompt.

Consejos para desarrollar con IA en Solana

Sigue estas recomendaciones para crear aplicaciones en Solana con IA:

1. Comienza con un prompt sólido

Un prompt del sistema funciona como la descripción del puesto de la IA. Le indica cuál es su función (por ejemplo, «Eres especialista en programación para Solana con Anchor...») y define las reglas que quieres que siga.

Este es un ejemplo típico, con algunos detalles adicionales:

# 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 qué funciona

Un prompt del sistema bien redactado funciona como un plano: alinea la IA con la arquitectura de Solana. Así, cada respuesta es precisa, segura y se adapta a tus necesidades.

1. Establece el contexto adecuado: Definir a la IA como «especialista en Solana» garantiza que se enfoque en funciones específicas de Solana, como las PDA, el paralelismo y Anchor, en lugar de hacer suposiciones genéricas sobre blockchains.
2. Genera código coherente: Incluir prácticas recomendadas, como controles de acceso estrictos y ejecución en paralelo, orienta a la IA para que produzca resultados seguros, confiables y predecibles.
3. Evita errores comunes: Destacar la seguridad de Rust, las macros de Anchor y la serialización reduce los errores. Esto te ahorra tiempo al depurar y reescribir código.
4. Aprovecha las fortalezas de Solana: La IA debe aumentar el ancho de banda y reducir la latencia. Esto optimizará el código para el alto rendimiento y la eficiencia de Solana.

2. Escribe prompts claros

Cuando le pidas a la IA que genere código, la precisión es fundamental. Cuanto más preciso seas, mejores serán los resultados. Compara estos ejemplos:

Prompt incorrecto:

«Escribe una función para inicializar una cuenta».

Este prompt es demasiado ambiguo. La IA no conoce el lenguaje de programación ni el framework, y tampoco sabe que el prompt busca generar código para Solana. Podría darte código genérico o inútil.

Prompt adecuado:

«Escribe una función en Rust que use Anchor para inicializar una cuenta de tokens de Solana. Usa una PDA derivada de una semilla. Valida el estado de la cuenta y gestiona los errores si la cuenta ya está inicializada».

Por qué funciona el prompt adecuado:

Los prompts claros ayudan a ahorrar tiempo y esfuerzo. Al aclarar los objetivos de la IA, evitas tener que corregir más adelante código descuidado, poco claro o mal orientado. También reduces las interpretaciones erróneas y haces que el trabajo con la IA sea más eficaz. 

1. Es claro y directo: Al mencionar Rust, Anchor y las PDA directamente, la IA sabe exactamente qué herramientas y funciones debe usar. No tendrá que adivinar ni incluir detalles irrelevantes.
2. Se enfoca en las necesidades de Solana: Mencionar una PDA indica a la IA que debe incluir lógica específica de Solana. Sin esto, el código podría omitir pasos importantes, como derivar direcciones de forma segura.
3. Agrega profundidad donde hace falta: Las instrucciones de validación y gestión de errores indican a la IA que debe ir más allá de lo básico. Esto ayuda a garantizar que el código funcione en situaciones reales.

Un buen prompt es como un mapa que orienta a la IA y la ayuda a evitar obstáculos para alcanzar sus objetivos.

3. Proporciona el contexto adecuado

La IA funciona mejor cuando le proporcionas el contexto adecuado. Muchas herramientas permiten cargar código o vincular archivos. Esto ayuda a la IA a entender tu proyecto y crear soluciones que se adapten a tu base de código. 

Pero no la sobrecargues. Proporcionar demasiada información a la IA, como una base de código grande y completa, puede hacer que alucine o genere respuestas irrelevantes. 

En su lugar, proporciona únicamente las partes relevantes de tu código. Así mantienes enfocada a la IA y mejoras la calidad de sus sugerencias.

Por ejemplo, imagina que tu aplicación ya tiene un archivo que define una estructura de datos personalizada:

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

Si cargas este archivo o lo incluyes como parte de la entrada, la IA puede usar los nombres exactos de tus campos (balance, is_initialized) en el código que genere.

También puede adaptar sus sugerencias a la estructura y las convenciones de tu proyecto.

Por qué funciona proporcionar contexto

1. Mejora la precisión: Sin contexto, la IA podría adivinar los nombres de los campos, introducir cambios innecesarios o asumir tipos de datos incorrectos. Por ejemplo, podría llamar amount a tu campo de saldo o usar un f64 en lugar de un u64. Proporcionar el struct real elimina estas suposiciones.
2. Mantiene la coherencia del código: Cuando la IA entiende tus convenciones de nomenclatura, produce código que encaja de forma natural en tu proyecto. Esto evita que tengas que renombrar variables o modificar el código para adaptarlo a tus patrones existentes.
3. Reduce el trabajo de integración: Si la IA ve las estructuras de tus cuentas, puede adaptar sus resultados para integrarlos directamente. Esto evita situaciones en las que el código generado por IA necesita grandes modificaciones para ajustarse a tu lógica existente.

Ejemplo: Cómo agregar contexto para mejorar los resultados de la IA

Sin el contexto adecuado, un prompt como «Escribe una función para actualizar el saldo de la cuenta de tokens» podría hacer que la IA genere 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(())
}

Este código tiene dos problemas:

Primero, usa f64 para la cantidad en lugar de u64. 

Solana ofrece muy poco soporte para la aritmética nativa de punto flotante. El enfoque recomendado es usar aritmética de punto fijo y escalar los números según los decimales utilizados. Esto evita problemas de rendimiento y compatibilidad.

Segundo, llama amount al campo de saldo, lo que no coincide con tu struct. Esto puede causar confusión y errores en el futuro.

Ahora, si proporcionas tu struct TokenAccount como contexto, la IA podría generar esto:

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

Este resultado se adapta mucho mejor a tu proyecto. 

Sin embargo, incluso con esta mejora, conviene agregar una comprobación de desbordamiento a la operación token_account.balance += amount para garantizar que el código sea sólido y seguro.

Cómo proporcionar contexto

Recuerda estos pasos para proporcionar el contexto adecuado a tus herramientas de IA:

1. Carga archivos: Si tu herramienta de IA lo permite, carga las definiciones de tus structs, los esquemas de cuentas y otros archivos del proyecto.
2. Incluye código de referencia en los prompts: Copia y pega fragmentos relevantes en tus prompts para que la IA pueda usarlos como referencia.
3. Describe la estructura: Si no puedes cargar archivos, describe claramente los datos en el prompt. Por ejemplo: «Tengo un struct llamado TokenAccount con los campos balance (u64) e is_initialized (bool).»

4. Aprovecha el código existente

No necesitas empezar desde cero cada vez. A menudo ya tienes un fragmento de código que funciona, pero podría mejorarse. La IA puede ayudarte a perfeccionarlo. Este es un ejemplo:

Este es el 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(())
}

Este código inicializa una cuenta de tokens y establece el saldo en cero. Es sencillo, pero no gestiona situaciones como actualizar una cuenta existente o verificar la propiedad.

Tu prompt:

«Haz que esta función sea más sólida. Si la cuenta de tokens existe, suma la cantidad al saldo. Si no existe, inicialízala con una cantidad específica. También verifica que el programa actual sea propietario de la cuenta».

Este es el código generado por IA después de tu 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 qué funciona

1. Aborda situaciones comunes: El nuevo código gestiona cuentas inicializadas y sin inicializar, lo que lo hace más útil en aplicaciones reales.
2. Agrega validación de propiedad: Esto evita cambios no autorizados porque el programa comprueba si es propietario de esa cuenta.
3. Hace que la función sea más inteligente: Ahora la función puede actualizar el saldo en lugar de restablecerlo a cero cada vez. Esto reduce la redundancia y se adapta a casos de uso reales.
4. Ahorra tiempo: No tuviste que reescribir toda la función. La IA amplió lo que ya tenías y aceleró el paso de una función básica a una sólida.

Cómo usar este enfoque

Recuerda estos pasos para aplicar este enfoque en el futuro:

1. Comienza con una base funcional: Identifica funciones o fragmentos que funcionen, pero puedan mejorarse.
2. Sé específico en tu prompt: Explica qué quieres mejorar, como agregar comprobaciones de errores, gestionar casos extremos o perfeccionar la lógica.
3. Revisa las sugerencias de la IA: Examina el resultado generado por IA para asegurarte de que se adapte a tu proyecto y siga las prácticas recomendadas de Solana.
4. Repite el proceso según sea necesario: Si el primer resultado no es perfecto, ajusta el prompt o edita el código para acercarte a tu objetivo.

5. Avanza paso a paso

Crear código paso a paso te ayuda a evitar errores y perfeccionar tu trabajo a medida que avanzas. En lugar de intentar crear una función compleja de una sola vez, divídela en tareas más pequeñas. Así será más fácil probar y mejorar cada parte antes de continuar.

Ejemplo de flujo de trabajo

Comencemos con algo pequeño. Pídele a la IA una función sencilla para calcular una dirección derivada de un programa (PDA) mediante una semilla.

Este es un ejemplo de prompt:

«Escribe una función de Rust que calcule una PDA a partir de una semilla y el ID de un programa mediante Anchor».

Resultado de la IA:

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

Este es un buen punto de partida, pero no está completo. Agreguemos gestión de errores.

Revisa el código e identifica los problemas. Por ejemplo, usar unwrap() puede hacer que el programa falle si la semilla no es válida.

Pídele a la IA que lo corrija:

«Actualiza esta función para incluir gestión de errores cuando las semillas no sean válidas. Devuelve un Result en lugar de usar unwrapping».

Código actualizado:

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

Ahora, la función gestiona correctamente las semillas no válidas al devolver un error en lugar de entrar en pánico.

A continuación, integremos la función. 

Pídele a la IA que use la función de la PDA en una rutina más amplia. Por ejemplo:

«Escribe una función que use esta PDA para crear una nueva cuenta de tokens. Verifica que la PDA no esté en uso».

Este es el resultado de la 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(())
}

Este paso integra la lógica de la PDA en la creación de la cuenta y garantiza que la PDA no se reutilice de forma incorrecta.

Ahora optimicemos y terminemos el código. Pídele a la IA que perfeccione aún más la función con un prompt como este:

«Optimiza esta función para minimizar los costos de transacción e incluye la validación de propiedad».

Este es el resultado de la 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(())
}

La función final ahora es eficiente, segura y sigue las prácticas recomendadas de Solana.

Por qué funciona este enfoque

1. Mantiene el proceso bajo control: Enfocarte en una tarea pequeña a la vez evita sobrecargar a la IA. Cada paso se basa en el anterior, lo que facilita probar y perfeccionar el código.
2. Detecta los errores a tiempo: Los pasos más pequeños permiten detectar problemas antes de que afecten al resto del código. Por ejemplo, agregar pronto la gestión de errores evita fallos posteriores.
3. Fomenta la iteración: Si algo no funciona a la perfección, puedes ajustar la función sin modificar toda la base de código.
4. Produce mejor código: Cada ajuste hace que el código sea más sólido. Al final, obtienes una solución más confiable y fácil de mantener.

Cómo usar este enfoque

Recuerda estos consejos la próxima vez que programes en pareja con IA:

1. Divide las tareas en pasos más pequeños: En lugar de solicitar una sola función compleja, divídela en tareas más sencillas y manejables, y ejecútalas una tras otra.
2. Prueba los resultados después de cada paso: Ejecuta el código después de cada cambio para confirmar que funciona. Si no funciona, corrige el problema o ajusta el prompt antes de continuar con el siguiente paso.
3. Perfecciona el código sobre la marcha: No te limites a un solo resultado. Pídele a la IA que optimice o agregue funciones como validaciones, mejoras de rendimiento o una mejor gestión de errores.

Conclusión

Usar IA para desarrollar en Solana puede ser muy potente si adoptas un enfoque cuidadoso y bien pensado. La arquitectura de Solana es diferente a la de otras blockchains: usa PDA, procesamiento de transacciones en paralelo y un diseño basado en cuentas. Por eso, debes orientar correctamente a la IA.

Comienza con prompts claros. Dile a la IA exactamente qué quieres y especifica las herramientas, como Rust, Anchor y las PDA. Un buen prompt podría decir:

«Escribe una función de Rust para inicializar una cuenta de tokens de Solana con una PDA, validar el estado de la cuenta y gestionar los errores.»

Esta claridad aumenta las probabilidades de que la IA produzca código que funcione en Solana.

Proporciona siempre contexto. Comparte el código de tu proyecto o explica las estructuras que usas, como los esquemas de cuentas o los tipos de datos. Por ejemplo, si tienes un struct TokenAccount, incluye sus detalles para que la IA pueda adaptar el resultado. Pero no la sobrecargues: enfócate en las partes relevantes para mantener la precisión y utilidad de las sugerencias.

Divide las tareas en pasos más pequeños. Usa un proceso iterativo para perfeccionar el código a medida que avanzas. Comienza con tareas sencillas, como calcular una PDA, y luego agrega gestión de errores o validación de cuentas. Haz pruebas después de cada paso. Así puedes detectar los problemas a tiempo y avanzar de forma constante.

Por último, revisa con cuidado el trabajo de la IA. El código generado por IA suele tener problemas menores, como comprobaciones de desbordamiento ausentes o validaciones omitidas. Asegúrate de que el resultado siga las reglas de Solana, no contenga errores y aproveche la ejecución en paralelo.

La IA es solo un punto de partida; tú debes terminar el trabajo. Con instrucciones claras, contexto, desarrollo paso a paso y una revisión cuidadosa, puedes usar IA para crear programas de Solana seguros y optimizados. Mantente involucrado en el proceso y la IA se convertirá en una herramienta valiosa para ahorrar tiempo y escribir mejor código.

Lecturas adicionales

Para obtener más información sobre cómo desarrollar con IA en Solana, explora estos recursos:

1. Anthropic: Descripción general de la ingeniería de prompts
2. AWS: Técnicas de ingeniería de prompts
3. Optimización de programas de Solana
4. Cómo optimizar el uso de cómputo en Solana
5. Documentación de Anchor