Comment utiliser l’IA pour créer des applications Solana

Défis du développement Solana avec l’IA

L’architecture et les exigences uniques de Solana peuvent poser problème à l’IA. Si elle ne les prend pas en compte, vous perdrez du temps à déboguer votre code ou à réécrire vos programmes, ce qui va à l’encontre de l’objectif consistant à utiliser l’IA pour simplifier le développement.

L’architecture unique de Solana

Solana se distingue principalement de trois manières :

1. Modèle basé sur les comptes

De nombreuses blockchains, comme Ethereum, associent directement les données au stockage interne d’un smart contract. À l’inverse, le modèle de programmation de Solana organise tout autour de « comptes ». Ces comptes contiennent les données, tandis que les « programmes » (l’équivalent des smart contracts sur Solana) modifient ces données et interagissent avec elles. 

Une différence essentielle tient au fait que, sur Solana, tout est un compte, y compris les programmes eux-mêmes. Les programmes sont simplement des comptes qui stockent des données exécutables, ce qui leur permet de traiter des instructions. À l’inverse, Ethereum distingue les comptes détenus en externe (EOA), contrôlés par des clés privées, des smart contracts, qui possèdent leur propre code et leur propre stockage interne. 

Cette différence fondamentale peut entraîner des malentendus, en particulier lors de l’écriture de code pour Solana. Comme avec les smart contracts Ethereum, les développeurs qui ne connaissent pas bien le modèle de comptes peuvent supposer à tort qu’un programme peut posséder ses données. De telles suppositions peuvent provoquer des erreurs d’exécution ou des vulnérabilités de sécurité lors d’un déploiement sur Solana.

2. Adresses dérivées de programmes (PDA)

Une adresse dérivée d’un programme (PDA) est créée à partir de l’identifiant d’un programme et d’une graine. Les PDA permettent aux programmes d’organiser des comptes sans nécessiter de clé privée. Toutefois, les modèles d’IA peuvent ne pas faire la différence entre une adresse standard et une PDA. S’ils oublient de gérer les graines ou de vérifier la propriété, le code Rust de la PDA sera correct, mais pas le code Solana.

3. Exécution parallèle

L’environnement d’exécution de Solana, Sealevel, lui permet de traiter les transactions en parallèle, contrairement aux blockchains traditionnelles qui les traitent une par une. Cela fonctionne parce que les transactions précisent les comptes qu’elles liront et modifieront. Grâce à ces informations, Solana peut déterminer quels comptes doivent être verrouillés et exécuter de nombreuses transactions simultanément en toute sécurité. 

L’IA comprend souvent mal ce modèle. Elle peut supposer que les transactions seront exécutées de manière séquentielle, comme dans l’Ethereum Virtual Machine (EVM). Cela peut produire du code qui n’exploite pas le parallélisme. Comme le système de verrouillage des comptes de Solana diffère de l’approche de l’EVM, l’IA peut écrire du code peu performant ou difficilement extensible.

Difficultés courantes

Les développeurs rencontrent régulièrement quelques problèmes lorsqu’ils utilisent l’IA pour créer des applications Solana :

1. Code incorrect

L’IA peut fournir des fonctions qui se compilent en Rust, mais échouent lors de leur déploiement sur Solana. Par exemple, les outils de programmation en binôme avec l’IA peuvent oublier des signataires ou mal interpréter les références de comptes. Le résultat ? Des bugs ou des vulnérabilités de sécurité que vous ne détecterez qu’en exécutant des tests ou de véritables transactions, ou en réalisant un audit de sécurité complet.

2. Code sous-optimal

Même si le code généré par l’IA fonctionne, il peut ne pas être optimisé pour les unités de calcul, ralentir le traitement des transactions ou introduire des goulets d’étranglement cachés. Imaginez une IA qui écrit une fonction pour mettre à jour les comptes un par un. Elle ne comprend pas que Solana peut les traiter simultanément si la fonction est correctement implémentée.

3. Débogage difficile

Les modèles d’IA ne connaissent ni la structure de vos dossiers ni la manière dont vous avez défini vos types de données personnalisés, sauf si vous leur fournissez ces informations. Ils peuvent donc proposer des solutions incompatibles avec votre configuration existante, et leur intégration dans votre projet peut devenir laborieuse.

Utilisez les outils d’IA Helius pour lancer plus rapidement vos applications Solana

Comme expliqué ci-dessus, utiliser l’IA pour développer correctement sur Solana n’est pas simple. 

Pour y remédier, nous avons créé une suite d’outils de développement Solana basés sur l’IA qui prend en charge les aspects complexes : sélectionner les bons outils, appliquer les bonnes pratiques et fournir à votre agent d’IA les bases nécessaires pour passer d’un simple prompt à une application prête pour la production.

Helius MCP Server

Le Helius MCP Server repose sur la norme ouverte Model Context Protocol (MCP) d’Anthropic et met plus de 60 outils structurés — notamment getBalance, parseTransaction, getAssetsByOwner et createWebhook — à la disposition de tout client compatible avec MCP (Claude Desktop, Cursor, VS Code, Windsurf, etc.).

Au lieu de construire des commandes curl brutes et d’analyser une sortie JSON, les agents effectuent des appels d’outils typés et reçoivent directement des réponses structurées. Chaque interaction avec l’API devient ainsi plus rapide, plus fiable et bien moins sujette aux erreurs.

Vous pouvez l’ajouter à Claude Code avec une seule commande :

claude mcp add helius npx helius-mcp@latest

Helius Skills

L’accès à plus de 60 outils ne sert à rien si un agent ne sait pas les utiliser.https://www.helius.dev/blog/helius-for-agents#helius-skills-the-brain

Les Skills sont des ensembles d’instructions expertes — des prompts soigneusement conçus avec une logique de routage et des fichiers de référence — qui apprennent à un agent à devenir un développeur Solana expert.

Lorsqu’une compétence est chargée, un agent sait qu’il doit utiliser searchAssets plutôt que getProgramAccounts pour rechercher des NFT, récupérer dynamiquement les frais de priorité et acheminer les transactions via Sender pour maximiser leur taux d’inclusion. 

Nous avons lancé quatre compétences :

• Build – Développement Solana de base avec toutes les API Helius
• DFlow – Applications de trading utilisant les API DFlow
• Phantom – Création d’interfaces pour les dApps avec le SDK Phantom Connect
• SVM – Fonctionnement interne approfondi du protocole Solana

Les compétences sont indépendantes des modèles et fonctionnent avec l’API OpenAI, l’API Claude, Cursor Rules et les instructions personnalisées de ChatGPT.

Pour proposer une compétence, veuillez remplir ce formulaire.

Helius CLI

Le Helius CLI est une interface de ligne de commande complète proposant plus de 95 commandes pour la gestion des comptes, l’envoi de transactions, la gestion des webhook, le streaming en temps réel, le staking, ZK Compression et bien plus encore. 

Vous pouvez l’utiliser directement ou laisser votre agent le piloter — chaque commande prend en charge la sortie --json et des codes de sortie structurés, ce qui permet aux agents d’analyser facilement les réponses et de gérer les erreurs de manière programmatique.

Installez Helius CLI comme suit :

npm install -g helius-cli

Helius Claude Code Plugin

Le Claude Code Plugin regroupe Helius MCP, DFlow MCP, les quatre compétences et des fichiers de référence détaillés pour chaque produit Helius dans une installation unique — sans configuration manuelle de MCP ni installation séparée des compétences.

Voici comment l’installer :

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

Une fois installé, un simple prompt comme « Crée une CLI de déclaration fiscale pour ce portefeuille » produit une application CLI entièrement fonctionnelle et paginée, sans nécessiter de prompts intermédiaires.

Ensemble, ces outils donnent aux agents d’IA accès aux outils et aux connaissances métier nécessaires pour éviter la phase d’essais et d’erreurs et produire du code Solana correct et optimisé dès le premier prompt.

Conseils pour le développement Solana avec l’IA

Suivez ces recommandations pour créer des applications Solana avec l’IA :

1. Commencez par un prompt solide

Un prompt système est comparable à la description de poste de l’IA. Il lui indique son rôle (par exemple, « Vous êtes un expert de la programmation Solana avec Anchor… ») et définit les règles à suivre.

Voici un exemple courant, légèrement enrichi :

# 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

Pourquoi cela fonctionne

Un prompt système bien rédigé agit comme un plan : il aligne l’IA sur l’architecture de Solana. Chaque réponse est ainsi précise, sécurisée et adaptée à vos besoins.

1. Il fournit le bon contexte : présenter l’IA comme une « experte de Solana » garantit qu’elle se concentre sur les caractéristiques propres à Solana, comme les PDA, le parallélisme et Anchor, plutôt que de formuler des hypothèses génériques sur les blockchains.
2. Il produit du code cohérent : l’inclusion de bonnes pratiques, telles que des contrôles d’accès stricts et l’exécution parallèle, aide l’IA à produire des résultats sécurisés, fiables et prévisibles.
3. Il évite les erreurs courantes : mettre en avant la sécurité de Rust, les macros Anchor et la sérialisation réduit les erreurs. Vous gagnez ainsi du temps sur le débogage et la réécriture du code.
4. Il exploite les points forts de Solana : l’IA doit augmenter la bande passante et réduire la latence. Le code sera ainsi optimisé pour le débit élevé et l’efficacité de Solana.

2. Rédigez des prompts clairs

Lorsque vous demandez à l’IA de générer du code, la précision est essentielle. Plus votre demande est précise, meilleurs seront les résultats. Comparez ces exemples :

Mauvais prompt :

« Écris une fonction pour initialiser un compte. »

Ce prompt est trop vague. L’IA ne connaît ni le langage de programmation ni le framework, et elle ne sait pas que le prompt concerne du code Solana. Elle risque de vous fournir du code générique ou inutile.

Bon prompt :

« Écris une fonction en Rust avec Anchor pour initialiser un compte de token Solana. Utilise une PDA dérivée d’une graine. Valide l’état du compte et gère les erreurs si le compte est déjà initialisé. »

Voici pourquoi le bon prompt fonctionne :

Des prompts clairs permettent d’économiser du temps et des efforts. En précisant les objectifs de l’IA, vous évitez de devoir corriger ultérieurement un code négligé, peu clair ou inadapté. Cela réduit également les erreurs d’interprétation et rend le travail avec l’IA plus efficace. 

1. Il est clair et direct : en mentionnant explicitement Rust, Anchor et les PDA, vous indiquez précisément à l’IA les outils et fonctionnalités à utiliser. Elle n’a pas besoin de deviner ni d’inclure des détails sans rapport.
2. Il se concentre sur les besoins de Solana : la mention d’une PDA indique à l’IA qu’elle doit inclure une logique propre à Solana. Sans cela, le code pourrait omettre des étapes importantes, comme la dérivation sécurisée des adresses.
3. Il apporte les précisions nécessaires : les instructions relatives à la validation et à la gestion des erreurs demandent à l’IA d’aller au-delà des bases. Cela contribue à garantir que le code fonctionne dans des situations réelles.

Un bon prompt est comme une carte qui guide l’IA, l’aide à éviter les pièges et lui permet d’atteindre ses objectifs.

3. Fournissez le contexte approprié

L’IA fonctionne mieux lorsque vous lui fournissez le contexte approprié. De nombreux outils permettent de charger du code ou d’ajouter des liens vers des fichiers. L’IA peut ainsi comprendre votre projet et créer des solutions adaptées à votre base de code. 

Mais ne la surchargez pas. Lui fournir trop d’informations, comme l’intégralité d’une vaste base de code, peut l’amener à halluciner ou à produire des réponses sans rapport. 

Concentrez-vous plutôt sur les parties pertinentes de votre code. L’IA restera ainsi focalisée et ses suggestions seront de meilleure qualité.

Par exemple, imaginez que votre application possède déjà un fichier définissant une structure de données personnalisée :

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

Si vous chargez ce fichier ou l’incluez dans votre saisie, l’IA pourra utiliser les noms exacts de vos champs (balance, is_initialized) dans le code généré.

Elle peut également adapter ses suggestions à la structure et aux conventions de votre projet.

Voici pourquoi fournir du contexte fonctionne

1. Améliore la précision : sans contexte, l’IA peut deviner les noms des champs, introduire des modifications inutiles ou supposer des types de données incorrects. Par exemple, elle pourrait appeler votre champ de solde amount ou utiliser un f64 au lieu d’un u64. Fournir la struct réelle élimine ces approximations.
2. Préserve la cohérence du code : lorsque l’IA comprend vos conventions de nommage, elle produit du code qui s’intègre naturellement à votre projet. Vous évitez ainsi de devoir renommer des variables ou remanier le code pour respecter vos modèles existants.
3. Réduit le travail d’intégration : si l’IA voit les structures de vos comptes, elle peut adapter directement sa sortie pour qu’elle s’y intègre. Vous évitez ainsi de devoir réécrire en profondeur le code généré par l’IA pour l’adapter à votre logique existante.

Exemple : comment ajouter du contexte pour améliorer les réponses de l’IA

Sans contexte approprié, un prompt comme « Écris une fonction pour mettre à jour le solde du compte de token » pourrait conduire l’IA à générer un code comme celui-ci :

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

Ce code présente deux problèmes :

Premièrement, il utilise f64 pour la quantité au lieu de u64. 

Solana ne prend en charge que de manière très limitée l’arithmétique native en virgule flottante. L’approche recommandée consiste à utiliser l’arithmétique en virgule fixe et à mettre les nombres à l’échelle selon le nombre de décimales utilisé, afin d’éviter les problèmes de performances et de compatibilité.

Deuxièmement, il nomme le champ de solde amount, ce qui ne correspond pas à votre struct. Cela peut entraîner de la confusion et des bugs par la suite.

Si vous fournissez maintenant votre struct TokenAccount comme contexte, l’IA pourrait plutôt générer ceci :

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

Cette sortie correspond bien mieux à votre projet. 

Toutefois, même avec cette amélioration, il est conseillé d’ajouter une vérification de dépassement de capacité à l’opération token_account.balance += amount afin de garantir la robustesse et la sécurité de votre code.

Comment fournir du contexte

Suivez ces étapes pour fournir le contexte approprié à vos outils d’IA :

1. Chargez des fichiers : si votre outil d’IA le permet, chargez vos définitions de struct, vos schémas de comptes et d’autres fichiers du projet.
2. Référencez du code dans les prompts : copiez et collez des extraits pertinents dans vos prompts afin que l’IA puisse les utiliser comme référence.
3. Décrivez la structure : si le chargement n’est pas possible, décrivez clairement vos données dans le prompt. Par exemple : « J’ai une struct appelée TokenAccount avec les champs balance (u64) et is_initialized (bool). »

4. Appuyez-vous sur le code existant

Vous n’avez pas besoin de repartir de zéro à chaque fois. Souvent, vous disposez déjà d’un morceau de code fonctionnel qui pourrait être amélioré. L’IA peut vous y aider. Voici un exemple :

Voici le code d’origine :

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

Ce code initialise un compte de token et définit son solde sur zéro. Il est simple, mais ne gère pas certains cas, comme la mise à jour d’un compte existant ou la vérification de sa propriété.

Votre prompt :

« Rends cette fonction plus robuste. Si le compte de token existe, ajoute la quantité à son solde. Sinon, initialise-le avec une quantité précise. Vérifie également que le programme actuel possède le compte. »

Voici le code généré par l’IA après votre 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(())
}

Pourquoi cela fonctionne

1. Gère les cas courants : le nouveau code prend en charge les comptes initialisés et non initialisés, ce qui le rend plus utile dans des applications réelles.
2. Ajoute une validation de la propriété : cela empêche les modifications non autorisées, car le programme vérifie s’il possède le compte.
3. Rend la fonction plus intelligente : la fonction peut désormais mettre à jour le solde au lieu de le réinitialiser à zéro à chaque fois. Cela réduit les redondances et correspond mieux aux cas d’usage réels.
4. Fait gagner du temps : vous n’avez pas eu à réécrire toute la fonction. L’IA a développé ce que vous aviez déjà, ce qui permet de passer plus rapidement d’une fonction basique à une fonction robuste.

Comment utiliser cette approche

Suivez ces étapes pour appliquer cette approche à l’avenir :

1. Commencez par une base fonctionnelle : identifiez les fonctions ou extraits qui fonctionnent, mais pourraient être améliorés.
2. Soyez précis dans votre prompt : expliquez ce que vous souhaitez améliorer, par exemple l’ajout de vérifications d’erreurs, la gestion des cas limites ou l’amélioration de la logique.
3. Examinez les suggestions de l’IA : vérifiez que la sortie générée par l’IA convient à votre projet et respecte les bonnes pratiques de Solana.
4. Itérez selon les besoins : si la première sortie n’est pas parfaite, ajustez votre prompt ou modifiez le code pour vous rapprocher de votre objectif.

5. Avancez étape par étape

Développer le code étape par étape vous aide à éviter les erreurs et à affiner votre travail au fur et à mesure. Au lieu d’essayer de créer une fonction complexe en une seule fois, divisez-la en tâches plus petites. Il est ainsi plus facile de tester et d’améliorer chaque partie avant de poursuivre.

Exemple de workflow

Commençons simplement. Demandez à l’IA une fonction simple permettant de calculer une adresse dérivée d’un programme (PDA) à partir d’une graine.

Voici un exemple de prompt :

« Écris une fonction Rust qui calcule une PDA à partir d’une graine et d’un identifiant de programme avec Anchor. »

Sortie de l’IA :

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

C’est un bon point de départ, mais la fonction n’est pas complète. Ajoutons la gestion des erreurs.

Examinez le code et identifiez les problèmes. Par exemple, l’utilisation de unwrap() peut entraîner le plantage du programme si la graine n’est pas valide.

Demandez à l’IA de corriger ce problème :

« Mets à jour cette fonction pour gérer les erreurs liées aux graines non valides. Renvoie un Result au lieu d’utiliser unwrap. »

Code mis à jour :

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

La fonction gère désormais correctement les graines non valides en renvoyant une erreur au lieu de provoquer un panic.

Intégrons maintenant la fonction. 

Demandez à l’IA d’utiliser la fonction PDA dans une routine plus large. Par exemple :

« Écris une fonction qui utilise cette PDA pour créer un nouveau compte de token. Vérifie que la PDA n’est pas déjà utilisée. »

Voici la sortie de l’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(())
}

Cette étape intègre la logique de la PDA à la création du compte tout en garantissant que la PDA n’est pas réutilisée de manière incorrecte.

Optimisons et finalisons maintenant le code. Demandez à l’IA d’affiner davantage la fonction avec un prompt comme celui-ci :

« Optimise cette fonction pour réduire les coûts de transaction et ajoute une validation de la propriété. »

Voici la sortie de l’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 fonction finale est désormais efficace, sécurisée et conforme aux bonnes pratiques de Solana.

Pourquoi cette approche fonctionne

1. Elle simplifie le travail : se concentrer sur une petite tâche à la fois évite de submerger l’IA. Chaque étape s’appuie sur la précédente, ce qui facilite les tests et les améliorations.
2. Elle détecte les erreurs rapidement : des étapes plus petites vous permettent de repérer les problèmes avant qu’ils n’affectent le reste du code. Par exemple, l’ajout précoce de la gestion des erreurs évite des plantages ultérieurs.
3. Elle favorise l’itération : si un élément ne fonctionne pas parfaitement, vous pouvez ajuster la fonction sans remanier toute la base de code.
4. Elle produit un meilleur code : chaque amélioration rend le code plus robuste et vous obtenez une solution plus fiable et plus facile à maintenir.

Comment utiliser cette approche

Gardez ces conseils à l’esprit lors de votre prochaine session de programmation en binôme avec l’IA :

1. Divisez les tâches en étapes plus petites : au lieu de demander une seule fonction complexe, décomposez-la en tâches plus simples et plus faciles à gérer, puis exécutez-les l’une après l’autre.
2. Testez les résultats après chaque étape : exécutez le code après chaque modification pour confirmer qu’il fonctionne. Dans le cas contraire, corrigez le problème ou ajustez le prompt avant de passer à l’étape suivante.
3. Affinez au fur et à mesure : ne vous limitez pas à un seul résultat. Demandez à l’IA d’optimiser le code ou d’ajouter des fonctionnalités, comme des validations, des améliorations des performances ou une meilleure gestion des erreurs.

Conclusion

Utiliser l’IA pour développer sur Solana peut être extrêmement efficace, à condition d’adopter une approche prudente et réfléchie. L’architecture de Solana diffère de celle des autres blockchains, notamment par son utilisation des PDA, du traitement parallèle des transactions et d’une conception basée sur les comptes. Vous devez donc guider correctement l’IA.

Commencez par des prompts clairs. Indiquez précisément à l’IA ce que vous souhaitez et mentionnez explicitement des outils comme Rust, Anchor et les PDA. Un bon prompt pourrait être :

« Écris une fonction Rust pour initialiser un compte de token Solana avec une PDA, valider l’état du compte et gérer les erreurs. »

Cette clarté augmente les chances que l’IA produise du code adapté à Solana.

Fournissez toujours du contexte. Partagez le code de votre projet ou expliquez les structures que vous utilisez, comme les schémas de comptes ou les types de données. Par exemple, si vous disposez d’une struct TokenAccount, fournissez ses détails afin que l’IA puisse adapter sa sortie. Mais ne la submergez pas : concentrez-vous sur les parties pertinentes pour que ses suggestions restent précises et utiles.

Divisez les tâches en étapes plus petites. Utilisez un processus itératif pour affiner le code au fur et à mesure. Commencez par des tâches simples, comme le calcul d’une PDA, puis ajoutez la gestion des erreurs ou la validation des comptes. Testez après chaque étape. Vous pourrez ainsi détecter rapidement les problèmes et progresser régulièrement.

Enfin, examinez attentivement le travail de l’IA. La plupart du temps, le code généré par l’IA comporte aussi des problèmes mineurs, comme l’absence de vérification des dépassements de capacité ou l’omission de certaines validations. Vérifiez que la sortie respecte les règles de Solana, ne comporte aucun bug et exploite les capacités d’exécution parallèle.

L’IA n’est qu’un point de départ : c’est à vous de terminer le travail. Avec des instructions claires, du contexte, un développement étape par étape et une vérification attentive, vous pouvez utiliser l’IA pour créer des programmes Solana sécurisés et optimisés. Restez impliqué dans le processus et l’IA deviendra un outil précieux pour gagner du temps et écrire un meilleur code.

Pour aller plus loin

Pour en savoir plus sur le développement avec l’IA sur Solana, consultez ces ressources :

1. Anthropic : présentation de l’ingénierie des prompts
2. AWS : techniques d’ingénierie des prompts
3. Optimiser les programmes Solana
4. Comment optimiser l’utilisation des ressources de calcul sur Solana
5. Documentation d’Anchor