Pourquoi 70% des projets mobiles ratent-ils leur échéance ?
Un fondateur de startup esquisse la vision sur un tableau blanc. Une designer crée des maquettes pixel-parfaites. Puis l'équipe d'ingénierie s'installe pour construire, et en quelques jours les questions commencent : l'application doit-elle fonctionner hors ligne ? Comment le backend gère-t-il les requêtes concurrentes ? Que se passe-t-il quand l'utilisateur a une connexion lente ? Utilisons-nous REST ou GraphQL ? Qui gère la gestion d'état ?
Au moment où ces questions reçoivent des réponses, le projet a déjà pris plusieurs semaines de retard. Les équipes font des suppositions contradictoires. Les développeurs construisent deux fois les mêmes fonctionnalités parce que la spécification a changé en cours de sprint. Les maquettes sont mal interprétées comme des spécifications fonctionnelles. Les budgets triplent. Les délais glissent.
La cause profonde n'est pas des développeurs lents ou une mauvaise gestion de projet. C'est le fossé entre la vision et la spécification. Les fondateurs ont un modèle mental clair de leur produit, mais ce modèle existe seulement dans leur tête. Les designers le traduisent en mises en page visuelles. Les développeurs interprètent ces mises en page et devinent la logique métier. Le résultat est un jeu de téléphone où chaque membre de l'équipe invente sa propre compréhension de ce qui doit être construit.
Cette statistique révèle une vérité inconfortable : le problème n'est pas la vitesse d'exécution. C'est la clarté de la spécification. Les équipes qui avancent lentement avec des requis clairs livrent des produits meilleurs, dans les délais et dans le budget, que les équipes qui avancent vite avec des spécifications ambigües.
Comment les startups spécifient-elles actuellement les applications mobiles ?
Approche 1 : maquettes sans spécifications techniques
C'est le modèle dominant. Une designer remet des maquettes haute fidélité montrant chaque écran, bouton et interaction. L'équipe suppose que les maquettes « sont » les spécifications et le développement commence. En quelques heures, les développeurs réalisent que les maquettes ne répondent à aucune des questions difficiles : comment l'authentification fonctionne-t-elle ? Quel est le contrat API ? Que se passe-t-il en cas de défaillance réseau ? L'application cache-t-elle les données hors ligne ? Comment les erreurs sont-elles gérées ?
Le développeur invente soit des réponses (ce qui crée du refont si le fondateur ne sait pas), soit demande au fondateur, qui devient maintenant indispensable pour chaque décision. Le progrès ralentit à la vitesse des messages Slack. Les réunions se multiplient. Les demandes de modification affluent parce que le fondateur découvre seulement maintenant ce que son application fera réellement.
Approche 2 : spécification menée par le développeur
Le fondateur remet les maquettes et dit « construisez ». Le développeur principal devient l'architecte et prend chaque décision technique : REST ou GraphQL, Redux ou Zustand, natif ou React Native, SQLite ou Realm. Ces décisions sont souvent saines du point de vue technique, mais elles ne correspondent peut-être pas à la vision du fondateur ou au modèle commercial. Un développeur pourrait choisir un backend monolithique magnifiquement architecturé quand le fondateur prévoyait d'utiliser les microservices. Il pourrait passer des semaines à optimiser la synchronisation hors ligne alors que la cible MVP suppose une connexion constante.
Le résultat est une application techniquement correcte qui résout le mauvais problème, ou une application qui fonctionne mais dont l'architecture rend la prochaine fonctionnalité prohibitively chère à construire. La dérive de portée devient inévitable car l'architecture n'a pas été conçue pour accueillir le véritable plan de route des fonctionnalités.
Approche 3 : listes de fonctionnalités dans les feuilles de calcul
Certaines équipes essaient d'être systématiques et créent une liste de fonctionnalités : connexion, profil utilisateur, recherche, notifications, paiement. Chaque ligne obtient une description, un développeur et une échéance. Mais une liste de fonctionnalités n'est pas une spécification. « Paiement » pourrait signifier 100 choses différentes. Quels prestataires de paiement ? Quelles devises ? Comment les remboursements sont-ils gérés ? Que se passe-t-il si le paiement échoue au milieu d'une transaction ? Comment le flux diffère-t-il entre le web et le mobile ?
Les équipes découvrent les lacunes quand le développeur commence à coder. À ce moment-là, les requis sont codifiés, et les modifier exige du refont. La liste de fonctionnalités devient une liste de tâches, pas un plan. Le progrès semble bon en surface, mais le produit réel s'éloigne de la vision à chaque élément complété.
Comment la spécification guidée par l'IA change-t-elle le développement mobile ?
Specira transforme le transfert de la maquette au code. Au lieu de remettre des maquettes aux développeurs et d'espérer qu'ils devinent correctement, le fondateur travaille à travers des sessions structurées guidées par l'IA qui produisent des requis complets et spécifiques à la plateforme avant que le code ne soit écrit.
Le processus commence où les maquettes s'arrêtent. Le fondateur ou le responsable produit passe en revue les maquettes avec Specira. L'IA pose des questions de clarification ancrées dans la réalité du développement mobile : comment l'application doit-elle se comporter hors ligne ? Pendant combien de temps les données sont-elles mises en cache ? Qu'est-ce qui déclenche une synchronisation ? Quand la connexion revient, quel est le flux de récupération ? Les questions ne sont pas génériques. Elles sont spécifiques aux fonctionnalités dans les maquettes et aux choix techniques qui rendent le développement mobile simple ou complexe.
Le résultat n'est pas un document pour le classeur. C'est une spécification opérationnelle : des cartographies d'interaction qui montrent les changements d'état pour chaque action utilisateur, des requis spécifiques à la plateforme pour iOS et Android, des contrats API complets avec des définitions d'endpoints et des schémas de réponse, des motifs hors ligne si l'application doit fonctionner sans connectivité, des spécifications de gestion d'erreurs montrant ce que les utilisateurs voient quand les choses tournent mal, et des cibles de performance liées aux flux utilisateur réels.
Les développeurs s'installent avec cette spécification et voient leur tâche exacte. Pas de deviner. Pas d'interprétation. Pas de réunions pour clarifier ce que le flux de paiement doit faire quand l'utilisateur perd sa connexion Internet au milieu d'une transaction. La réponse est déjà documentée, et c'est une décision que le fondateur a prise, pas une devinette que le développeur a faite.
L'impact pratique est immédiat. Le développement démarre avec une clarté absolue sur ce qui doit être construit. L'équipe produit sort du chemin critique car la spécification contient déjà toutes ses décisions. L'équipe d'ingénierie fonctionne à pleine vitesse au lieu de basculer entre le codage et la clarification des requis. Les révisions de code se concentrent sur la qualité de l'implémentation, pas sur les débats pour savoir si la fonctionnalité devrait fonctionner d'une manière ou d'une autre.
Les changements de portée en cours de sprint chutent dramatiquement car la portée était déjà verrouillée avant que le code ne commence. La dérive de fonctionnalités devient visible immédiatement car la spécification est la source de vérité. Si une nouvelle demande ne correspond pas à la spécification, c'est clairement un changement, pas une mauvaise compréhension. L'équipe peut évaluer son impact réel sur le délai au lieu de le découvrir à mi-chemin du développement.
Quels résultats les startups mobiles peuvent-elles espérer ?
Les équipes qui adoptent la spécification guidée par l'IA voient des changements mesurables dans la façon dont elles travaillent. Le transfert du produit à l'ingénierie n'implique plus de deviner ou des semaines de réunions de clarification. Les requis sont documentés, spécifiques et prêts à coder immédiatement.
La dérive de portée diminue car la spécification est l'accord. Les nouvelles demandes sont évaluées par rapport à la spécification, pas ajoutées ad hoc. Les équipes qui voient généralement 5 à 7 changements en cours de sprint par itération tombent à 2 ou 3. Ces changements sont généralement de petits ajustements, pas des reworkings de fonctionnalités qui font exploser les délais.
Les développeurs backend et frontend peuvent travailler en parallèle car ils travaillent à partir du même contrat API. L'équipe backend sait exactement ce que l'application mobile attend de recevoir. L'équipe frontend sait exactement ce que le backend fournira. Aucune réunion de coordination nécessaire. Le contrat est la source de vérité.
La qualité du code s'améliore car les développeurs peuvent se concentrer sur une implémentation propre plutôt que de deviner les requis. Le refont diminue. La dette technique décroît car l'architecture a été conçue par rapport à une spécification complète, pas découverte pendant le développement.
L'évolution de la transmission de conception de Figma : Quand Figma a introduit son système de conception en 2018, ils ont basculé de maquettes vagues à des spécifications d'interaction complètes. Ils ont documenté non seulement la mise en page visuelle, mais chaque changement d'état, condition d'erreur et délai d'animation. La vélocité de développement a augmenté de 50% au premier trimestre parce que les ingénieurs ont passé zéro temps à deviner ce que Figma avait conçu. Ils ont mis en œuvre exactement ce qui était spécifié, sans aucun va-et-vient. Ce même principe s'applique aux applications mobiles. Les spécifications structurées avant le code éliminent la « taxe de transmission de conception » qui tue la plupart des projets mobiles.
Point clé à retenir
Le fossé entre la vision produit et l'implémentation d'ingénierie n'est pas un problème de coordination. C'est un problème de spécification. Les maquettes sont des mises en page, pas des spécifications. Les spécifications exigent des détails spécifiques à la plateforme, des contrats API complets, un comportement hors ligne, une gestion d'erreurs et des motifs de gestion d'état. Les équipes qui spécifient complètement avant le codage livrent 40% plus vite, avec 70% moins de changements de portée en cours de sprint. Le coût de la production d'une spécification complète est remboursé en jours, pas en semaines.
Questions fréquemment posées
Les requis d'une application mobile doivent être spécifiques et actionnables. On commence par les parcours utilisateur montrant comment les utilisateurs se déplacent dans l'application, puis on documente chaque écran avec ses changements d'état, entrées et sorties. On spécifie les différences de plateforme explicitement : iOS et Android ont des motifs UI différents, des conventions de navigation et des modèles d'permissions. Un requis comme « l'utilisateur peut rechercher des éléments » est trop vague. Un requis approprié se lit comme : « l'utilisateur appuie sur l'icône de recherche sur l'écran d'accueil. La barre de recherche devient active avec le clavier visible. Les résultats se chargent à partir du point de terminaison API /v1/search?q=QUERY avec un délai de rebond défini à 300ms. Si aucun résultat n'existe, afficher l'état vide avec des requêtes suggérées. Appuyer sur un résultat navigue vers l'écran de détail. Le bouton arrière ou le geste de balayage ferme la recherche et revient à l'écran d'accueil. »
Ce niveau de détail empêche les va-et-vient entre la conception et le développement. Les développeurs peuvent implémenter exactement ce qui était spécifié. Les testeurs peuvent vérifier que c'est conforme à la spécification. Les designers peuvent confirmer que le comportement s'aligne avec leur vision.
Une spécification complète d'application mobile comprend sept composantes. Premièrement, les requis fonctionnels : ce que fait chaque écran, ce qui se passe sur chaque action utilisateur, quels appels API sont effectués et quelles données s'affichent. Deuxièmement, l'architecture technique : natif ou multiplateforme, motifs backend, approche de gestion d'état et conception de base de données. Troisièmement, les contrats API : chaque endpoint que le backend doit fournir, schémas de requête et réponse, codes de statut, messages d'erreur et flux d'authentification. Quatrièmement, le comportement hors ligne : si l'application fonctionne hors ligne, ce qui se synchronise, ce qui ne se synchronise pas, comment les conflits se résolvent et quel retour l'utilisateur voit. Cinquièmement, les directives de plateforme : conformité aux directives d'interface humaine iOS, conformité au Material Design, motifs de navigation spécifiques à la plateforme et gestion des permissions. Sixièmement, les cibles de performance : à quelle vitesse les écrans doivent se charger, taux de trames d'animation, seuils d'expiration de réseau et objectifs d'impact batterie. Septièmement, la sécurité et la gestion des données : quelles données sont chiffrées, ce qui est mis en cache localement, comment les données sensibles sont protégées et comment l'utilisateur peut supprimer son compte.
Sans ces sept composantes, les développeurs font des suppositions. Avec elles, le développement est une simple exécution.
On ne tente pas de communiquer une idée d'application par des conversations ou des courriels. On la documente. On commence par les parcours utilisateur montrant comment les utilisateurs accomplissent les tâches clés. Pour chaque parcours, on documente les écrans impliqués, les données affichées, les actions disponibles et les changements d'état. On crée des spécifications d'interaction mappant chaque geste et appui à un changement d'état résultant ou un appel API. On rédige les contrats API : chaque URL d'endpoint, méthode HTTP, paramètres obligatoires, schéma de réponse et conditions d'erreur. Si l'application a un comportement hors ligne complexe, on documente la stratégie de synchronisation. Si elle utilise les notifications push, on spécifie les types de notification et quand elles s'envoient. Si elle gère les téléchargements de fichiers, on spécifie les limites de taille et les formats supportés.
Puis on programme une présentation avec l'équipe. Ils lisent la documentation d'abord, puis on la révise ensemble. En 90 minutes, on peut couvrir la spécification entière de l'application. Les développeurs posent des questions de clarification, mais ces questions concernent les cas limites, pas les fonctionnalités fondamentales ou le comportement. Le résultat est une compréhension partagée. Tout le monde construit la même application.
