En 2022, un MVP me prenait 6 à 8 semaines. Aujourd'hui je tourne autour de 4 à 6 jours pour un cas équivalent.

Ce n'est pas du clickbait, c'est mesuré sur une quarantaine de projets. Et non, l'IA ne remplace pas les développeurs — mais à compétence égale, le dev qui l'utilise sérieusement sort plus de boulot que celui qui ne l'utilise pas, et l'écart se creuse vite.

Ce qui suit, c'est ce que j'utilise vraiment, dans l'ordre où je m'en sers, et où ça se casse la gueule.

Les chiffres, avant qu'on parle outils

Productivité avant/après IA

Mesures TechSprint (2022 vs 2025) :

Tâche	Avant IA	Avec IA	Gain
Setup projet	4-6h	30 min	90%
CRUD API	1-2 jours	2-3h	85%
UI Components	4-5h/composant	1h/composant	80%
Tests unitaires	1 jour	2-3h	75%
Documentation	2-3 jours	4-5h	83%
Debug complexe	4-8h	1-2h	75%

Vélocité globale mesurée : +312% sur l'ensemble des projets. Je précise : c'est une moyenne, pas une garantie. Sur les projets vraiment nouveaux ou atypiques, le gain tombe parfois à 30-40%.

ROI financier

Coût dev d'un MVP stack Next.js :

2022 : 15-20 jours × 600€ = 9 000-12 000€
2025 : 4-6 jours × 600€ = 2 400-3 600€

Soit environ 70% d'économie côté développement pur.

Les 5 outils qui tournent en permanence chez moi

1. GitHub Copilot — l'autocomplete qui comprend le contexte

Exemple typique :

// Je tape "// Function to validate email"
// Copilot génère automatiquement :
function validateEmail(email) {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return emailRegex.test(email);
}

Ce qu'il fait bien :

environ 80% du code boilerplate généré sans y penser
autocomplete contextuel sur plusieurs lignes
squelettes de tests unitaires corrects
suggestions de refactor raisonnables

Ce qu'il rate : dès qu'il s'agit de logique métier spécifique ou d'une lib récente, les propositions deviennent médiocres et il faut les corriger. J'ai appris à m'arrêter sur la moindre complétion qui "a l'air plausible" — c'est souvent là qu'il invente une API.

ROI mesuré : +47% de vélocité sur le développement pur. Prix : 10$/mois (rentabilisé en 2h de gain par mois).

2. ChatGPT-4 — l'architecte technique virtuel

Mes cas d'usage :

Architecture & Planning :

Prompt : "Je développe un SaaS de gestion RH pour PME. 
Architecture Next.js + Prisma + PostgreSQL. 
Donne-moi la structure de base de données optimale."

Résultat : Schéma complet + relations + index en 30 secondes

Code review :

Prompt : "Review ce code React et suggère des améliorations :
[coller le code]"

Résultat : Analyse + suggestions d'optimisation

Debug :

Prompt : "Cette erreur Next.js : [erreur]
Contexte : [code concerné]"

Résultat : Solution + explication + prévention

ROI mesuré : -60% sur le temps de réflexion, recherche et debug. À prendre en compte : les schémas de BDD qu'il propose sont souvent trop normalisés pour un MVP. Je les retravaille systématiquement.

3. Cursor — l'éditeur avec l'IA intégrée dans le workflow

Ce qui m'a fait switcher depuis VSCode :

chat intégré avec le contexte complet du projet
Edit mode pour modifier du code en place
Composer pour générer plusieurs fichiers d'un coup
debug avec analyse contextuelle de l'erreur

Exemple concret :

Moi : "Ajoute un système de notifications toast à cette app"
Cursor : 
1. Installe sonner
2. Crée le composant Toaster
3. Ajoute dans layout.tsx
4. Crée des fonctions utilitaires
5. Montre des exemples d'usage

Sur les features standard : 90% de temps gagné. Sur du code legacy mal documenté, Cursor se perd autant que moi.

4. v0.dev — la génération d'UI de Vercel

Ce qu'il produit :

composants React prêts à poser
design Tailwind cohérent
compatibilité shadcn/ui
code souvent utilisable tel quel

Workflow type :

Prompt : "Dashboard analytics avec charts et KPIs"
Résultat : composant complet en 10 secondes
Customisation via prompts de suivi
Copy/paste dans le projet

Gain : -80% sur les composants UI. Attention : v0 a tendance à produire des composants verbeux et à dupliquer de la logique. Une passe de refactor est quasi obligatoire avant intégration.

5. Claude 3.5 Sonnet — celui que je sors pour les problèmes durs

C'est celui sur lequel je bascule quand les autres plafonnent. Ce qu'il fait mieux que les autres selon mon usage :

refactor complexe multi-fichiers
patterns d'architecture avancés
optimisation de perfs
documentation technique qui reste lisible

Exemple concret :

Moi : "Optimise cette requête Prisma qui devient lente :
[requête complexe avec joins]"

Claude : 
1. Analyse des bottlenecks
2. Requête optimisée avec include selectif
3. Index database suggérés
4. Solution de cache Redis
5. Monitoring recommandé

Mon workflow concret, étape par étape

Phase 1 — Planning & architecture (ChatGPT-4)

1. Analyse du besoin

Prompt template :
"Analyse ce brief projet : [brief]
Recommande :
1. Architecture technique optimale
2. Stack recommandée
3. Estimation développement
4. Points d'attention"

2. Database design

"Conçois le schéma de données pour [description fonctionnelle]
Format : Prisma schema avec relations
Inclus : index, contraintes, optimisations"

3. Wireframes fonctionnels

"Liste les screens nécessaires pour [app description]
Format : User flow + wireframes textuels
Focus : UX optimale et conversion"

Phase 2 — Développement (Copilot + Cursor)

1. Setup projet

# Prompt Cursor : "Setup Next.js 15 + TypeScript + Tailwind + Prisma"
# Résultat : configuration complète en 5 minutes

2. Génération de composants (v0.dev)

"Dashboard SaaS avec sidebar, header, et zone contenu principale"
→ Copy/paste code généré
→ Ajustements via prompts de suivi

3. API (Copilot)

// Comment : "API route pour créer un utilisateur avec validation"
// Copilot génère automatiquement la logique complète

Phase 3 — Qualité & optimisation (Claude + ChatGPT)

1. Code review

"Review ce composant React :
[code]
Critères : performance, sécurité, maintainabilité, best practices"

2. Génération de tests

"Génère des tests Vitest pour cette fonction :
[function]
Inclus : edge cases, mocks, coverage 100%"

3. Documentation

"Documente cette API :
[routes]
Format : README technique + exemples d'usage"

Les erreurs que je vois (et que j'ai faites)

Erreur 1 : confiance aveugle

L'IA génère régulièrement du code subtilement faux. Exemple récent : une méthode Prisma qui n'existait plus depuis la v5, utilisée avec l'aplomb d'une doc officielle.

Ce que je fais :

100% du code IA est relu avant commit
tests systématiques sur la logique métier
je garde en tête qu'aucun modèle n'a le contexte complet du projet

Erreur 2 : prompts trop vagues

Mauvais prompt :

"Fais-moi un composant form"

Bon prompt :

"Crée un formulaire de contact Next.js avec :
- Champs : nom, email, message  
- Validation Zod
- Styling Tailwind CSS
- Submit vers API route
- Toast notifications
- State management useState"

Erreur 3 : oublier la sécurité

L'IA ne pense pas spontanément à :

validation des inputs côté serveur
sanitization des données
gestion des erreurs
rate limiting
authentification/autorisation

J'ai une checklist sécurité que je passe après chaque génération d'endpoint.

Erreur 4 : dépendance excessive

Risque que j'observe chez moi et chez les devs juniors :

perte de compréhension du code qu'on "possède"
debug devient pénible parce qu'on n'a pas construit le modèle mental
maintenance plus compliquée six mois plus tard
skills techniques qui stagnent

J'alterne volontairement : environ 70% IA, 30% écrit à la main, notamment sur la logique métier critique.

5 projets concrets

1. SaaS de gestion RH (B2B)

Avant IA : 6 semaines. Avec IA : 8 jours.

Répartition :

Architecture : ChatGPT pour modélisation BDD
UI/UX : v0.dev pour tous les composants
Backend : Copilot pour APIs + validations
Tests : Claude pour couverture

Résultat : client en production 3 semaines plus tôt que prévu.

2. Marketplace produits locaux

Besoin : vendeurs / acheteurs / commandes, avec les subtilités qui vont avec.

Workflow :

ChatGPT pour les patterns e-commerce
Cursor pour la génération des CRUDs
v0.dev pour interface produits et panier
Copilot pour logique métier et paiements

Gain : 75% de temps de développement économisé.

3. App mobile PWA (React Native)

Contexte : première fois sur React Native pour l'équipe. J'ai surtout utilisé l'IA comme formation accélérée.

ChatGPT pour les concepts RN
Cursor pour la configuration Expo
adaptation de patterns web vers mobile
Claude pour les erreurs iOS/Android

Compétence utilisable en une semaine au lieu du mois que j'aurais prévu sans IA.

4. Dashboard analytics

Contraintes : 50+ KPIs, 12 types de charts, temps réel.

Répartition :

Performance : Claude pour optimisations React
Charts : v0.dev + intégration Recharts
Data : Copilot pour transformations
UX : ChatGPT pour quelques arbitrages d'ergonomie

Performance finale 3x meilleure que la version précédente (qui était clairement sous-optimisée).

5. API multi-tenant

Enjeu : isolation des données entre tenants.

ChatGPT pour les patterns éprouvés
Copilot pour le code Prisma
Claude pour la review sécurité
génération des tests end-to-end

Qualité : 0 bug de sécurité identifié à la review externe, archi validée.

Par où commencer (plan 30 jours)

Semaine 1 — Setup et premiers essais

Outils à installer :

GitHub Copilot (10$/mois)
ChatGPT Plus (20$/mois)
Cursor Editor (gratuit/premium)

Objectif : remplacer 30% du code boilerplate.

Exercices :

générer quelques composants UI simples
utiliser Copilot pour l'autocomplete
se frotter au prompt engineering de base

Semaine 2 — Intégrer l'IA au workflow

Objectif : systématiser l'usage.

À pratiquer :

prompts contextuels précis
code review avec IA
debug assisté

Mesurer le temps gagné vraiment, pas à l'œil.

Semaine 3 — Techniques plus poussées

architecture guidance avec IA
génération de tests
documentation auto-générée

Semaine 4 — Bilan

gains de productivité mesurés
points d'amélioration identifiés
workflow personnalisé qui commence à se stabiliser

Objectif atteignable : 50-70% de gain de vélocité après un mois de pratique régulière.

Où va le développement avec l'IA

Tendances qui se dessinent

Développement agentique Des IA qui codent de façon plus autonome, avec un humain qui valide. Déjà visible aujourd'hui, mais encore fragile sur des projets non triviaux.

Multimodal Générer du code depuis un wireframe, un schéma, une vidéo de démo. Les premiers résultats sont prometteurs, mais loin d'être prêts pour de la prod sérieuse.

Modèles spécialisés Modèles fine-tunés par framework ou par domaine. Le contexte enterprise personnalisé devient un vrai sujet.

Ce qui ne change pas

Ce sur quoi l'IA est encore largement en retrait :

comprendre un vrai besoin utilisateur
décisions d'architecture stratégiques
debug de problèmes vraiment complexes (ceux où la cause est à trois niveaux du symptôme)
évaluation qualité et sécurité
coordination d'équipe et mentoring

Si vous voulez s'y mettre

Le plus dur ce n'est pas l'install — c'est de prendre l'habitude de relire ce qui sort. Donnez-vous un mois pour mesurer (vraiment, pas à l'œil) le temps gagné sur trois ou quatre tâches récurrentes. Si vous ne voyez rien après 30 jours, soit vous prompt mal, soit votre stack ne s'y prête pas. Dans les deux cas c'est un signal utile.

Si vous voulez en parler 30 minutes : calendly.com/contact-techsprint. Je peux aussi vous dire honnêtement que vous n'avez pas besoin d'aide externe pour démarrer.

Fabrice Payet — TechSprint, j'utilise ces outils tous les jours depuis 2022.

IA et développement : Comment multiplier sa productivité par 10