De 0 à 5 Apps en Production : Comment j'ai Multiplié ma Productivité par 10 avec Claude Code

Les faits

En 6 semaines, j'ai livré et maintenu 5 projets en production (iOS + Web), représentant environ 50 000 lignes de code, avec des scores Lighthouse à 96/100 et une architecture incluant SwiftData, CloudKit, MongoDB et Stripe. Non, Claude n'a pas codé à ma place. Il a amplifié mes compétences et m'a permis de me concentrer sur ce qui compte : l'architecture et la valeur créée.

Mon parcours

Je suis développeuse iOS de passion, avec l'objectif d'en faire mon métier à temps plein. On entend partout que l'IA va remplacer les développeurs. Je n'y crois pas. L'IA va transformer le métier, c'est certain. Mais elle va surtout amplifier ceux qui comprennent comment l'utiliser.

Les projets livrés

Calendio (SaaS Web) : 95 fichiers, 23 588 lignes, Next.js 15 + MongoDB + Stripe, déployé sur Vercel. Mon premier SaaS où j'ai appris les fondamentaux : connexion MongoDB, implémentation Stripe, le tout en utilisant Claude en mode explicatif et apprentissage. Le MVP est en ligne.

Keepio (iOS) : Restructuration complète suite à un audit de Claude sur l'app. Résultat : +3000 lignes de code en moins, une app plus performante et une charge mentale allégée.

ios-development-agents : Un framework de 7 plugins ultra-granulaires pour le développement iOS, en constante amélioration pour répondre à mes besoins plus rapidement.

Caffio (iOS) : Application autour du café où j'ai exploré le framework FoundationModels et utilisé Claude pour mettre en place un système de gestion de projet (Agile, sprints de 2 semaines, user stories à jour dans Jira via MCP).

EchoSwift (Bot Discord) : Grâce au MCP Discord, Claude m'a accompagnée pour créer un bot fonctionnel. Il était déployé et opérationnel en 3 heures.

La question se pose : comment est-ce possible ? La réponse n'est pas "l'IA a tout codé". La vraie réponse est bien plus nuancée.

Casser les idées reçues

"L'IA va coder à ma place"

En réalité, l'IA amplifie les développeurs qui savent l'utiliser. Sur Calendio, quand j'ai voulu implémenter Stripe, j'ai guidé chaque décision architecturale. Claude a généré le code, mais c'est moi qui ai défini la structure, identifié les manques (gestion du currentPeriodEnd, stripeCustomerId dans Artisan, logique de vérification des limites) et exigé zéro ts-ignore.

Le résultat : un système Stripe complet et type-safe. Mais j'ai dirigé chaque étape.

"Le code IA est de mauvaise qualité"

C'est nuancé. Le code IA reflète la qualité des instructions qu'on lui donne.

Sur Keepio, j'ai demandé un audit à Claude Code avec des notes, des recommandations et de l'aide sur l'optimisation. L'architecture est passée d'une structure classique par type de fichier à une architecture par module avec des UseCases, du filtrage dynamique @Query, et une synchronisation CloudKit fonctionnelle.

J'ai validé le résultat après avoir compris les compromis (meilleure encapsulation contre navigation plus profonde dans Xcode). C'est moi qui ai choisi après avoir pesé le pour et le contre.

"L'IA rend paresseux"

Au contraire, elle élève le niveau de réflexion. On passe de "Comment coder cette fonction de tri ?" à "Comment architecturer ce système pour qu'il supporte 10 000 utilisateurs ?". On passe de 2 heures à déboguer un Optional unwrap à 30 minutes avec feedback continu. La procrastination sur la documentation disparaît quand elle est générée au fil de l'eau.

La transformation réelle : je suis passée de "technicienne qui code des lignes" à "architecte qui conçoit des systèmes".

Mon workflow en 3 phases

Phase 1 : Architecture d'abord (20% du temps)

L'IA accélère l'implémentation, mais une mauvaise architecture ralentira tout par la suite.

Mon processus :

1. Esquisser l'architecture manuellement (diagrammes, flux de données)
2. Demander à Claude de challenger mes choix : "Quels sont les risques ? Quelles alternatives ?"
3. Valider ou ajuster en fonction des compromis identifiés

Phase 2 : Implémentation collaborative (60% du temps)

Claude code, je valide et j'ajuste.

Mon processus :

1. Des prompts précis : "Implémente la synchronisation CloudKit avec gestion des conflits. Utilise le pattern actor-based pour la thread-safety."
2. Validation systématique : lecture de chaque ligne générée, tests des cas limites
3. Itérations rapides : affiner le prompt plutôt que corriger manuellement

Phase 3 : Optimisation et documentation (20% du temps)

Claude excelle dans la refactorisation et la documentation.

Mon processus :

1. Code review : "Analyse ce code, identifie les opportunités d'optimisation"
2. Refactoring : "Refactorise cette fonction pour améliorer la lisibilité sans changer le comportement"
3. Documentation : "Génère la documentation technique de ce module avec exemples d'usage"

Les techniques avancées

Le prompt en 3 niveaux

Niveau 1 -- Contexte : décrire le problème métier Niveau 2 -- Contraintes : spécifier les contraintes techniques Niveau 3 -- Action : demande précise avec format attendu

Résultat : du code précis qui correspond exactement aux besoins, souvent production-ready dès la première itération.

Le système de plugins ultra-granulaire

Dans ios-development-agents, j'ai créé 7 plugins Claude spécialisés : ios-architecture, swift-language, swift-concurrency, swiftui-views, swiftui-state, swiftdata-models, ios-orchestration.

Les avantages :

• Economie de tokens d'environ 90% grâce à la spécialisation (prompt de 2K tokens au lieu de 20K)
• Qualité supérieure car chaque plugin est expert dans son domaine
• Maintenance facilitée : mettre à jour un plugin n'impacte pas les autres

Ce que l'IA ne fait pas

Comprendre les besoins utilisateur implicites. Sur Keepio, Claude a généré une liste fonctionnelle mais sans feedback visuel sur les projets en retard, ni quick actions, ni indicateurs de progression. L'empathie utilisateur reste humaine.

Gérer la dette technique à long terme. L'IA optimise pour la solution immédiate. Sur Calendio, j'ai refusé une solution de cache Redis proposée par l'IA car le trafic actuel ne le justifie pas et MongoDB avec de bons index suffit amplement.

Ma règle d'or

L'IA code, je décide et je valide. Jamais l'inverse.

Les 3 principes à retenir

1. Architecture d'abord : l'IA accélère, mais il faut une vision claire
2. Prompts précis : Contexte + Contraintes + Action = Code de qualité
3. Validation systématique : lire, tester, profiler chaque ligne critique

Ce que j'ai changé dans ma pratique : je ne code plus jamais de boilerplate manuellement, je demande à l'IA de challenger mes décisions d'architecture, je génère la documentation en même temps que le code, et je passe 70% de mon temps à réfléchir et 30% à coder.