A retenir
- Un outil gratuit de programmation IA locale m’a permis de créer une application Mac que j’utilise réellement.
- Un débogage complexe a mis en évidence les limites de mon contexte de 64 Ko.
- Les petites tâches sont utiles, mais Claude Code reste mon outil de prédilection.
Un outil gratuit de programmation IA en local permet de créer une application Mac simple, mais d’après mon expérience, il n’est pas fiable pour le débogage. Ces dernières semaines, j’ai utilisé Qwen, Ollama et OpenCode avec un contexte de 64 000 tokens sur mon Mac Studio M4 Max doté de 128 Go de RAM. La pile s’exécute entièrement sur mon Mac et m’a permis de créer un utilitaire de renommage de captures d’écran. Cependant, ma tentative de création d’un organiseur de PDF s’est enlisée lors du débogage. J’ai donc décidé que, pour les projets plus importants, je m’en tiendrais à Claude Code.
J’ai plusieurs décennies d’expérience en programmation et plus d’un an de codage « agentic vibe » à mon actif. Cette expérience a été enrichissante, mais aussi l’une des plus frustrantes de toute ma carrière de programmeur. C’est ma deuxième incursion dans le codage IA gratuit. La première, en février 2026, s’est soldée par un échec total. Celle-ci s’est révélée plutôt prometteuse. Après de très nombreuses heures de bricolage, de frustration et de petites victoires, j’ai beaucoup appris sur les forces et les faiblesses de la programmation d’IA locale.
J’ai également trouvé des réponses à mes trois grandes questions.
- Une pile de programmation d’IA locale libre et open source peut-elle créer une application Mac ? Oui, bien sûr.
- Peut-elle créer une application sophistiquée et complète ? Pas question.
- Est-ce que j’abandonnerais Claude Code pour cette solution ? Seulement si j’y étais obligé, mais même dans ce cas, probablement pas.
Ma configuration gratuite de développement d’IA locale sur un Mac Studio
Ma machine principale de développement est un Mac Studio de 128 Go équipé d’un processeur M4 Max. Il dispose d’une mémoire vive très importante. Mais comme l’ont montré mes tests précédents avec 64 Go sur un processeur RTX Spark, il faut davantage de RAM pour que l’environnement de développement d’IA local dispose d’un contexte exploitable. Cela correspond essentiellement à la quantité de code et au nombre d’interactions que l’IA peut gérer avant de devoir effacer son état de conscience et repartir de zéro.
Sur cette machine équipée d’un RTX Spark, j’ai utilisé une combinaison de llama.cpp, OpenCode et Qwen-coder pour effectuer quelques tests de programmation. Lorsque je lui ai fourni une application Mac complète et que je lui ai demandé de la traduire pour une utilisation sous Windows, la pile de codage a réussi à progresser suffisamment pour afficher une interface utilisateur rudimentaire.
Cette expérience était surtout un coup médiatique. Pour cet article, mon objectif était de créer une véritable application utilisable qui m’aide à résoudre un problème concret. Spoiler : Ça a marché, mais de justesse.
J’ai conservé OpenCode comme environnement de développement agentique, en passant à la version 2.2.5. J’avais déjà Ollama qui tournait sur mon Mac dans un environnement de fenêtrage Mac classique exécutant le code llama.cpp. J’ai donc continué à utiliser Ollama.

Pour le codage, j’ai alterné entre deux modèles. J’ai utilisé qwen3-coder-next:q4_K_M, un modèle de 80 milliards de paramètres qui n’utilise que 3 milliards de paramètres actifs à la fois. Cela le rend rapide.
Ce modèle Qwen est conçu pour les agents de codage et montre son raisonnement au fur et à mesure qu’il réfléchit aux problèmes. Il a globalement bien fonctionné dans les limites de ses contraintes pratiques, même s’il lui arrivait parfois d’insérer des caractères chinois dans ses réponses textuelles. C’est tout à fait normal, puisque Qwen est un modèle conçu en Chine par Alibaba.

Voici une anecdote amusante. Qwen est souvent appelé Tongyi Qianwen, ce qui signifie « La vérité issue de mille questions ». On ne peut pas trouver de nom plus parfait que celui-là.
J’ai également utilisé Gemma4:26b car c’est un modèle multimodal. Gemma est loin d’être aussi douée pour le codage que Qwen-coder. Mais je pouvais lui fournir une capture d’écran, et elle était capable de l’interpréter. Son problème, c’est qu’elle a tendance à s’emballer et qu’elle ne communique pas beaucoup pendant qu’elle travaille, ce qui fait qu’elle se perd très facilement.
La plupart du temps, j’utilisais simplement Qwen. Mais les rares fois où j’avais vraiment besoin que le modèle comprenne une capture d’écran, je lançais Gemma.
Quant à OpenCode, j’ai simplement créé un dossier pour mon travail sur OpenCode, ouvert Terminal, accédé au dossier OpenCode, puis exécuté le harness dans Terminal. Cela reflète la façon dont j’utilise Claude Code, qui réside dans iTerm2.
Ensuite, pour vérifier que l’installation avait bien fonctionné, je lui ai demandé de créer une application très simple affichant le message canonique « Hello, world ».

L’échec du codage IA local avec un organiseur de PDF sous macOS 27
S’il y a une seule chose à retenir de cet article, c’est celle-ci : Fin 2026, le codage IA local n’est pas capable d’effectuer de manière fiable un débogage complexe. Je l’ai appris à mes dépens.
L’IA locale n’est tout simplement pas capable de conserver suffisamment de contexte pour suivre les allers-retours nécessaires au débogage diagnostique. Ce premier projet était entièrement axé sur le débogage diagnostique. Il a finalement échoué. C’est pourquoi j’ai dû passer à quelque chose de plus simple.
L’un de mes tests de codage agentique habituels consiste à demander aux agents d’organiser un gros dossier de PDF en renommant les fichiers pour les rendre plus descriptifs et en les classant dans des dossiers par thème. Comme macOS 27 intègre désormais une IA embarquée capable de comprendre le sens des documents, j’ai décidé de transformer mon défi d’organisation de PDF en une application.
Grosse erreur. Le modèle de base permettant de comprendre le sens des documents est très, très récent. Il n’est pas bien documenté. Et il n’est certainement pas intégré à la base de connaissances de l’IA de programmation.
J’ai passé cinq jours entiers à m’enliser dans ce labyrinthe, à essayer de faire en sorte qu’OpenCode trouve la bonne documentation en ligne, se familiarise avec les API et développe l’application.
J’ai en fait réalisé de réels progrès. Mon application était capable d’analyser un PDF et de renvoyer des informations sur le sujet du document. Mais elle n’était pas capable de le faire de manière répétée. Il y a un écart considérable en termes de gestion de la mémoire et de limites de l’IA lorsque la portée du projet passe de l’analyse d’un seul document à celle d’une centaine ou d’un millier à la fois.

Comprendre et diagnostiquer la gestion de la mémoire, la gestion des sessions et les limites inhérentes à un tout nouveau sous-système d’IA embarqué dépassait tout simplement les capacités de ma pile d’IA locale, compte tenu de son contexte limité.
Ainsi, après une semaine qui m’a semblé perdue et vraiment décevante, j’ai décidé de me ressaisir.
Comment j’ai développé une application Mac qui renomme les captures d’écran grâce à l’IA locale
Pour ma deuxième tentative, j’ai choisi un projet qui utilise des interfaces macOS datant de la nuit des temps : afficher une liste de fichiers, sélectionner des répertoires, afficher une image et saisir du texte. Rien de nouveau, d’inconnue ou d’indocumenté.
Le projet en lui-même est simple, mais c’est quelque chose dont j’ai réellement besoin. Je prends énormément de captures d’écran, probablement entre 20 et 50 pour chaque article que j’écris. Mon outil de prédilection est CleanShot X, qui génère des fichiers nommés du type « CleanShot 2026-10-27 à 15 h 26 min 15 s@2x ». Je dispose d’un dossier contenant plus de 7 000 images, toutes dotées de ce format de nom peu pratique.
Je cherchais un outil rapide qui me permettrait d’ouvrir un dossier d’images, d’afficher une image à la fois et de la renommer. Dès que j’appuie sur Retour, je veux que l’application enregistre le nouveau nom, puis charge et affiche la capture d’écran suivante.

J’ai effectivement créé l’application, même si cela m’a pris près de six jours pour la terminer. C’est parce que j’ai passé quatre jours à essayer de convaincre l’IA d’afficher une liste de fichiers dans ce volet de gauche.
Finalement, j’ai tout simplement supprimé tout le code d’affichage des fichiers, lancé une nouvelle instance d’OpenCode sans aucune connaissance de ce qui s’était passé auparavant, puis je lui ai demandé de générer la liste des fichiers. Pas de débogage. Pas d’affinage. Rien d’autre pour la perturber. Finalement, ça a marché.
Pourquoi un contexte de 64 000 tokens a compliqué le débogage
Soyons clairs : afficher une liste de fichiers n’est pas difficile. J’aurais pu écrire ce code à la main en une heure ou deux. Mais je voulais prouver qu’une IA locale pouvait écrire une application entière. J’ai donc passé quatre jours à me battre avec la fonctionnalité de liste.
Le défi ici revenait à ce que j’ai dit plus tôt : les IA locales ont du mal à déboguer du code. Dans le processus itératif du débogage, on trouve des indices, on accumule des bribes de connaissances, on effectue des tests et, finalement (avec un peu de chance), on a une révélation. Claude Code, avec son contexte d’un million de tokens, s’en sort à merveille. OpenCode, avec un contexte limité à 64 000 tokens, échoue lamentablement sur ce point.
L’application est plutôt sympa, mais j’ai dû limiter ses fonctionnalités. Il n’y a pas de barre de défilement pour redimensionner les volets gauche et droit. Il n’y a pas de modèles de noms de fichiers ni de dates pour les nouveaux fichiers. Il n’y a pas de fonction de zoom pour examiner l’image plus en détail. Il n’y a pas de touches fléchées ni de boutons pour passer rapidement d’un nom de fichier à l’autre.
Toutes ces fonctionnalités ne sont que des fioritures qui auraient dû être intégrées et déboguées. Je ne me déteste tout simplement pas assez pour me lancer dans une nouvelle bataille de débogage juste pour quelques fonctionnalités un peu plus sophistiquées.
Mais bon, mission accomplie. J’ai créé une application Mac entièrement fonctionnelle en utilisant uniquement l’IA, de manière entièrement locale, sur mon ordinateur.
Bonnes pratiques pour le développement local d’IA avec OpenCode et Ollama
D’après mon expérience, je peux diviser cela en deux grandes catégories : la pile technologique que vous utilisez et les pratiques de codage que vous adoptez. Commençons par la pile technologique.
J’ai choisi deux modèles différents car ils présentaient chacun des atouts uniques. Mais attention. Ne laissez pas OpenCode choisir le modèle. J’ai configuré de petits raccourcis en ligne de commande pour n’ouvrir qu’un seul modèle à la fois. Ainsi, je pouvais choisir délibérément le modèle que j’utilisais, et OpenCode ne pouvait pas se contenter d’utiliser au hasard le premier venu.
Les modèles sont évalués à la fois en fonction de leur taille (en milliards de paramètres) et du nombre de paramètres actifs. Les paramètres actifs se trouvent dans les modèles MoE (« mixture of experts »), qui activent efficacement un sous-ensemble d’experts (les capacités d’IA) lorsque ceux-ci deviennent pertinents. J’ai testé un modèle de 27 milliards de paramètres et un modèle « mixture of experts » de 80 milliards de paramètres qui activait 3 milliards de paramètres à la fois. Le plus gros modèle MoE était six fois plus rapide, même s’il utilisait beaucoup plus de RAM.
Soyez extrêmement vigilant quant au verrouillage des autorisations sur ces modèles. Ils n’hésiteront pas à lancer des commandes shell, à déplacer et à supprimer des fichiers et des répertoires. Leur tendance à être assez incompétents rend dangereux de les laisser agir sans surveillance. Je me suis assuré qu’ils demandent une autorisation pour chaque action qu’ils souhaitaient effectuer. C’était plus fastidieux, mais plus sûr.
Passons maintenant aux pratiques de codage. Mon premier conseil, et le plus important, est de redémarrer la session à chaque nouvelle correction, fonctionnalité ou problème. Si vous limitez suffisamment le sujet, l’IA locale pourrait être capable de le gérer. Dès que vous ajoutez quelques éléments supplémentaires… écureuil !! L’IA s’enfuira et se perdra ou se bloquera.
L’IA ne dispose pas non plus de commande d’archivage ou de suivi. J’ai modifié le fichier AGENTS.md pour lui demander d’enregistrer ses apprentissages et son processus, mais j’ai constaté que le simple fait de lire ces instructions lui faisait consommer trop de contexte. J’ai donc gardé AGENTS.md très court et demandé à l’IA d’écrire des fichiers .md séparés, qu’elle ne consulterait qu’à la demande.
Séparez complètement la recherche du codage. Si vous voulez que l’IA comprenne comment une fonctionnalité est codée, vous pouvez lui confier une recherche. Demandez-lui de rédiger un fichier .md avec ses conclusions. Ensuite, dans une session totalement distincte, demandez-lui de lire ce fichier et de commencer à coder.
Le débogage est le talon d’Achille de l’IA locale. Si vous avez la malchance de rencontrer un bug, vous devrez guider l’IA pas à pas à chaque étape, même mineure, de la correction. N’oubliez pas de redémarrer la session entre chaque test et chaque observation.
Enfin, comme je l’ai appris, veillez à ce que le projet reste de petite envergure. L’IA locale ne peut pas gérer une application volumineuse en utilisant des appels d’API qui viennent tout juste d’être publiés. Vous pouvez créer des applications simples. Mais elle ne peut vraiment pas gérer de grosses applications, à moins de l’utiliser avec beaucoup de parcimonie.
Le codage gratuit avec une IA locale peut-il remplacer Claude Code ?
Je vais répondre à cette question en revenant sur mes trois questions initiales.
Une pile de codage IA locale, gratuite et open source, peut-elle créer une application Mac ? Oui, c’est tout à fait possible. Mon application « Screenshot Rename » fonctionne vraiment. Je l’ai même utilisée aujourd’hui pour la série de captures d’écran de cet article. C’est un grand pas en avant par rapport à ce que nous connaissions auparavant. Vous pouvez désormais avoir un programmeur junior (très junior) qui vit dans votre ordinateur.
Peut-elle créer une application sophistiquée et complète ? Non. Pas la moindre chance. Du moins, pas en utilisant les modèles locaux. Les applications volumineuses nécessitent des contextes importants. J’utilise un contexte de 64 000 tokens avec cette solution d’IA locale. Mais pour mes principaux projets de codage dans Claude Code, je consomme régulièrement un contexte d’un million de tokens cinq ou six fois par nuit.
Vous pourriez peut-être utiliser un environnement local comme OpenCode avec un LLM distant peu coûteux fonctionnant sur une plateforme telle que le cloud d’Ollama. Mais à ce stade, Codex ou Claude Code pourraient s’avérer être de meilleures solutions.
Est-ce que j’abandonnerais Claude Code pour cette solution ? Non. Claude Code et Codex sont des outils incroyables, véritables multiplicateurs de puissance, qui ont complètement transformé ma façon de coder. Cette solution d’IA locale était à peine réalisable et fastidieuse.
J’y ai consacré la majeure partie de deux semaines (week-ends compris), au moins une demi-journée de travail par jour, et tout ce que j’ai à montrer, c’est une application rudimentaire de renommage d’images. J’aurais pu coder ça à la main en quelques soirées seulement, avec beaucoup moins de stress. La seule raison pour laquelle je n’ai pas abandonné, c’est pour pouvoir écrire cet article.
Ce qui m’amène à la question que me posent souvent les lecteurs.
Le codage local gratuit avec ambiance IA est-il suffisant pour les non-programmeurs ? Non. Absolument pas. Du moins, pas encore. J’ai passé la majeure partie de mon temps à enseigner, à amadouer, à déboguer et à corriger des erreurs de code et des malentendus. Tout cela nécessitait une expérience en programmation. Si vous êtes débutant, un environnement de programmation local basé sur l’IA vous coûtera plus cher que ce qu’il ne vous apportera jamais.
Maintenant, comparez cela à Codex et Claude Code. Tous deux peuvent devenir des partenaires de programmation. Si vous leur donnez les bonnes instructions et que vous réfléchissez bien à ce que vous voulez, il y a de très bonnes chances qu’ils vous fournissent une véritable application et qu’ils puissent même vous apprendre à programmer.
En résumé : la programmation IA locale est pratique, mais vous devez veiller à limiter la complexité et à bien comprendre les limites des modèles. Pour certaines applications très spécifiques, comme mon astuce de renommage d’images, ce n’est pas mal. Mais ne partez pas du principe qu’elle peut coder toute seule, ne vous attendez pas à ce qu’elle débogue ses erreurs, et veillez à la guider à chaque étape.
À l’issue de ce projet fastidieux de deux semaines, je retiens deux enseignements.
Le premier est que je suis un peu déçu que le codage local par IA présente les limites que j’ai décrites et ne soit pas encore vraiment prêt pour un travail de codage sérieux.
La seconde, c’est que, sans avoir besoin du cloud, d’un centre de données ni de quoi que ce soit de particulièrement imposant, un boîtier de la taille d’une boîte à goûter classique Scooby-Doo a en fait permis de créer un utilitaire Mac qui va m’aider dans mon travail quotidien.