Comment développer un produit IA qui marche vraiment en production

90 % des POC IA ne passent jamais en prod. Soit parce que les coûts d'inférence explosent, soit parce que la qualité ne tient pas sur les cas réels, soit parce que personne ne sait mesurer si ça « marche ».

Voici la méthode qu'on applique chez Zetos sur les produits IA, distillée de 6 produits livrés en 2024-2025 (Moriarty, The Patch, CS Consulting et autres).

Pas de hype. Pas de promesse irréaliste. Juste ce qui sépare un produit IA en prod d'un POC qui meurt en démo.

La règle d'or : commence par l'évaluation, pas par le prompt

C'est l'erreur n°1 qu'on voit chez 80 % des fondateurs et équipes tech qui démarrent un projet IA. Ils écrivent un prompt, demandent à Claude/GPT, regardent si « ça a l'air bien », passent à autre chose.

Le bon ordre, c'est l'inverse. Avant d'écrire le moindre prompt, tu dois pouvoir répondre à ces questions :

1. Qu'est-ce qu'une « bonne réponse » dans mon cas ?
2. Combien d'exemples j'ai où je connais la bonne réponse ?
3. Comment je mesure automatiquement si une nouvelle réponse est bonne ?

Si tu ne peux pas répondre, tu n'as pas un projet IA. Tu as une intuition.

Concrètement, construis un set d'évaluation : 50 à 200 cas (input + output attendu) que tu vas faire tourner à chaque modification de prompt, à chaque changement de modèle, à chaque release. C'est ton garde-fou.

Sans set d'éval, tu ne sais pas si ton produit s'améliore ou se dégrade quand tu changes quelque chose. Tu navigues à vue.

La stack qui marche en 2026

Brique	Notre choix par défaut	Quand on s'écarte
LLM raisonnement	Claude 4 Opus / Sonnet	GPT-5 si features OpenAI spécifiques (vision avancée, voice realtime)
LLM volume / classification	Claude Haiku, GPT-4o-mini, Mistral Small	Llama 3.3 self-hosted si RGPD strict
Embeddings	Voyage AI ou OpenAI text-embedding-3	Mistral Embed si Europe-only
Vector DB	pgvector si Postgres déjà là, sinon Qdrant	Pinecone pour très gros volumes ou multi-region
Orchestration	LangGraph ou Mastra	Custom si besoin de contrôle fin
Observabilité	Langfuse (open-source) ou LangSmith	Helicone si full-managed
Front streaming	Vercel AI SDK	Custom si stack Vue/Svelte

Notre conviction : partir des API propriétaires pour 80 % des cas. Self-hosted Llama/Qwen seulement quand RGPD ou volumétrie l'imposent. La qualité Claude/GPT en 2026 est encore devant les open-weights pour le raisonnement complexe.

Les 4 phases d'un produit IA Zetos

Phase 1 — Audit usage (1-2 semaines)

On identifie où l'IA crée vraiment de la valeur vs « gimmick à la mode ». Question filtre : est-ce que le bénéfice utilisateur > le coût d'inférence + le temps de latence + la friction d'erreurs ?

Si la réponse est non, on dit non au projet. Mieux vaut perdre un client que livrer un produit qui ne sert à rien.

Phase 2 — Choix de la stack (1 semaine)

On évalue 2-3 modèles candidats sur le set d'éval. Critères : qualité, coût/requête, latence, contraintes données. On choisit la stack avec un argumentaire écrit (pas « parce que Claude c'est cool »).

Phase 3 — Build itératif (4-12 semaines)

Un use-case d'abord. Cycles de 2 semaines. À chaque cycle :

• Démo produit
• Évaluation auto sur le set d'éval
• Mesure coût d'inférence sur l'échantillon utilisateur

On étend seulement quand les 3 courbes (qualité, coût, satisfaction) sont saines.

Phase 4 — Production avec observabilité (1-2 semaines)

Avant le go-live :

• Observabilité branchée (Langfuse capture chaque appel, sa sortie, son coût)
• Guardrails applicatifs (validation de format, retry, fallback modèle)
• Monitoring drift (alerte si la qualité moyenne baisse de X %)
• Plan rollback documenté

Sans ces 4, on ne met pas en prod. C'est une règle ferme.

Les 5 pièges qu'on voit le plus

1. POC qui n'a pas de chemin clair vers la prod. Tu fais un POC, tu démontres que ça marche sur 5 cas. Personne ne sait comment scaler à 10 000. Refaire à zéro coûte plus cher qu'avoir bien commencé.

2. Pas de mesure de qualité automatisée. Sans set d'éval, tu ne sais pas si tu progresses ou régresses. Le moindre changement de prompt devient une roulette russe.

3. Coûts d'inférence explosés en prod. Tu testes sur 100 requêtes, tout va bien. Tu lances avec 50 000 utilisateurs, ta facture mensuelle Claude passe de 50 € à 8 000 €. Les caches, le batching, le choix de modèle deviennent critiques.

4. Hallucinations non gérées. Tu sors du texte libre sans citations sources, sans validation structurée, sans guardrail. Premier client touche un cas où le LLM invente une donnée critique. Tu perds le client et la confiance des autres.

5. Pas de fallback. Le jour où Claude tombe pendant 4 heures (ça arrive 1 à 2 fois par an), ton produit s'effondre. Toujours prévoir : retry → fallback modèle (Claude → Mistral par exemple) → fallback applicatif (l'utilisateur voit l'expérience non-IA).

Ce qu'on a fait chez Zetos

3 produits IA-natifs en prod en 2024-2025 :

Moriarty — agent vertical qui croise 2 000+ aides publiques avec le profil d'une entreprise. Stack : Claude 4 Sonnet + RAG sur base custom + interface Next.js. Eval set de 300 cas tournant avant chaque release.

The Patch — simulateur d'entretien IA pour étudiants. LLM avec contexte poste + CV, scoring automatique des réponses. PWA + streaming via Vercel AI SDK.

CS Consulting — intégration IA dans une plateforme métier existante. Classification automatique de tickets, génération de comptes-rendus.

Sur chaque projet : set d'éval avant le code, observabilité Langfuse, monitoring coût quotidien, fallback obligatoire. Aucun n'a eu d'incident majeur en prod.

Combien ça coûte vraiment

Format	Build	Coût d'inférence/mois	Délai
POC interne	8-15 k€	50-200 €	3-4 semaines
MVP IA en prod	30-60 k€	200-1 500 €	6-10 semaines
Produit IA mature	80-200 k€	1 500-8 000 €	4-6 mois
Agent vertical complexe	150-400 k€	3 000-15 000 €	6-9 mois

Le coût d'inférence est la variable que tu dois maîtriser. On le dimensionne dès le cadrage et on l'optimise (cache, modèle plus léger, batching) avant le go-live.

Bottom line

Si tu démarres un produit IA :

1. Set d'évaluation avant le prompt. Sans ça, ne commence pas.
2. API propriétaires d'abord. Self-hosted seulement si RGPD ou volume justifie.
3. Observabilité dès le commit 1. Langfuse ou LangSmith, pas plus tard.
4. Fallback obligatoire. Aucune feature critique ne dépend d'un seul modèle.
5. Coût d'inférence mesuré quotidiennement. La facture peut tripler en une semaine.

Si tu veux qu'on regarde ton projet IA, contacte-nous via cadrage. À la fin tu repars avec un avis tech argumenté + un chiffrage build et inférence.