Comment j'ai arrêté de me sentir dépassé par une grosse tâche

Avant, quand je devais réaliser un gros écran d'application ou une intégration que je ne connaissais pas, je bloquais. J'ouvrais l'éditeur, je regardais un fichier vide sans comprendre par où commencer. Ensuite, deux scénarios. Soit du code chaotique, que l'on a honte de relire par la suite, soit deux heures sur YouTube sous prétexte qu'il fallait que je m'y penche. Aujourd'hui, je travaille autrement. Le changement s'est révélé simple, mais j'ai mis longtemps à y venir.
Les symptômes
Si vous vous reconnaissez, le cas vous est familier :
- Vous ouvrez un fichier, vous écrivez la première ligne, vous l'effacez
- Cinq ou six allers-retours vers Google en cinq minutes
- Au bout d'une heure de code, la sensation que « tout est faux, je vais repartir de zéro »
- Au fond de vous, vous aimeriez que quelqu'un vous dise exactement quoi faire
- Chaque petite décision ralentit. Où mettre le fichier, comment nommer une variable, faut-il utiliser une bibliothèque
Ce n'est pas de la paresse. C'est une surcharge cognitive. La tête essaie de garder en même temps dans son champ de vision l'objectif, l'architecture, la syntaxe, les noms, les cas limites. Chacun de ces éléments mobilise des ressources, et quand tout arrive en même temps, le cerveau décroche tout simplement.
La citation qui m'a accroché
Ilya Krasinsky a dit un jour : « Nous ne pouvons pas nous permettre des releases longues, elles coûtent infiniment trop cher. » Je travaillais alors sur mon premier produit, et cette phrase a touché un point sensible.
Les releases longues, ce n'est pas seulement lent. Quand je travaille deux semaines sur une seule tâche, je perds l'élan des deux premiers jours. Les décisions qui semblaient évidentes au début finissent par susciter des doutes. Le contexte se dissout, et vous passez un quart de journée de travail à revenir là où vous vous êtes arrêté la veille.
C'est de là qu'est née ma règle personnelle. Si un fondateur sait coder lui-même, tester une hypothèse lui coûte plusieurs fois moins cher. Non pas parce qu'il ne dépense rien pour un développeur, mais parce qu'entre « j'ai eu l'idée » et « j'ai vu la réaction de l'utilisateur », il s'écoule des jours, pas des mois.
Pour coder vite soi-même, il faut arrêter de bloquer. C'est là qu'entre en jeu la décomposition.
La méthode
Cela paraît banal, c'est pourquoi je l'ai longtemps ignorée.
Avant d'ouvrir l'éditeur, j'ouvre une note et j'écris les étapes.
Pas un plan dans Notion avec des tags et des estimations. Pas un ticket Jira. Juste une liste à puces dans le premier endroit venu. Le but est de sortir de la tête ce que le cerveau essaie de retenir en parallèle de l'écriture du code.
J'écris les étapes jusqu'au moment où elles deviennent trop évidentes. Voilà le critère d'arrêt. Si l'étape suivante ressemble à « appeler la fonction X avec tels paramètres », c'est qu'il n'y a plus besoin de détailler. À partir de là, le travail commence dans le code.
Pendant que j'écris les étapes, l'essentiel se produit. Les inconnues remontent. Je me surprends à me demander « mais comment ce serveur renvoie exactement les données ? », « est-ce qu'une animation est nécessaire ici ? », « et si l'utilisateur n'a pas d'internet ? ». Chaque question de ce type devient soit un point à part, soit une tâche « préciser avec le client, chercher dans la documentation ».
Au bout de 15-30 minutes de décomposition, je comprends la tâche fondamentalement mieux. Et j'aborde le code avec une première étape concrète, et non avec la question « par où commencer, au fait ».
Un exemple de projet réel
Je vais le montrer sur une tâche du projet client No Sugar Challenge. Il fallait faire un système d'onboarding personnalisé avec du scoring. Autrement dit, l'utilisateur passe par quatre groupes de questions, les réponses permettent de calculer des paramètres personnels, puis l'application construit pour lui des tâches quotidiennes.
Au départ, j'aurais ouvert un nouveau fichier OnboardingViewModel.swift et j'aurais commencé à écrire la classe. Et je me serais bloqué à la deuxième ligne.
Au lieu de cela, j'ai ouvert une note et j'ai écrit :
- Décrire la structure : un groupe de questions, un ensemble de
Question, chaque question avec un type de réponse et un poids - Décider comment stocker la réponse intermédiaire. En mémoire dans le ViewModel ou dans Core Data
- Les paramètres utilisateur que nous calculons à partir des réponses : apport calorique de référence, rythme de vie typique, niveau de motivation. Où ces formules sont-elles décrites ?
- Le scoring. Chaque réponse a un poids, à la fin du groupe on additionne, on rattache à un paramètre
- Les bloqueurs dynamiques. Certaines réponses doivent bloquer les questions suivantes (exemple : « pas d'allergies », on saute le bloc sur les allergènes)
- La sortie de l'onboarding. Où va-t-on, qu'est-ce qu'on sauvegarde
- La persistance. Ce qui se trouve dans Firestore (event-driven, voir l'architecture du projet), ce qui se trouve en local
- Les tests. Quels edge cases sont importants : réponse sautée, réponse d'exception, retour à l'étape précédente
Quand j'ai eu fini d'écrire, trois choses sont devenues visibles :
- Il vaut mieux faire la structure
Questionsous forme d'énumération (enum) avec des associated values selon le type de réponse - Les formules de scoring, je ne les connais pas : c'est une question pour le client, ce n'est pas à moi de les inventer
- Les bloqueurs dynamiques sont une tâche à part avec une logique indépendante : mieux vaut les isoler dans un service dédié
Après cela, j'ai fait deux choses. J'ai envoyé la question sur les formules au client et je me suis mis à écrire le code. Les deux premières heures sont passées sur la structure Question et Answer plus un routage simple entre les questions. À la fin de la première journée, j'avais un onboarding fonctionnel sur des données de test statiques. Sans bloqueurs, sans scoring, mais une charpente fonctionnelle.
Si j'avais commencé « comme d'habitude », j'aurais passé les deux premières heures à réfléchir, puis j'aurais fait une classe avec les réponses sous forme de dictionnaire de chaînes, puis je serais allé refactoriser. Et à la fin de la journée, j'aurais eu la moitié de ce que j'ai maintenant.
Quand la décomposition n'est pas nécessaire
Parfois, la décomposition gêne. Si la tâche se résume à une simple retouche de styles, à une modification de texte ou à un remplacement d'image, mettez-vous-y et faites-le. Détailler des étapes comme « trouver le fichier, l'ouvrir, le modifier, l'enregistrer », c'est de la bureaucratie.
Pour moi, la limite est à peu près celle-ci. Si j'ai une image mentale précise du résultat et que je connais la première action, je le fais tout de suite. S'il manque ne serait-ce qu'un de ces deux points, j'ouvre une note.
Par ailleurs, la décomposition fonctionne mal sur les tâches de recherche. Quand je me penche sur une nouvelle technologie, par exemple quand je découvre PassKit pour Apple Wallet pour la première fois, je ne peux pas établir de plan : je n'en sais pas assez pour l'écrire. Dans ces cas, je travaille dans l'ordre inverse. Je farfouille dans le code, je comprends un petit détail, puis un deuxième, et seulement ensuite je m'assois et j'écris un plan « maintenant, j'en sais assez pour faire les choses pour de vrai ».
À propos de l'estimation des délais
La même méthode sert à estimer les délais pour un client. Sans décomposition, je dis « trois jours », et c'est presque toujours un mensonge. Avec la décomposition, je regarde ma liste de 8 à 15 points, j'estime chacun en heures, j'additionne, je multiplie par 1,5 (parce que j'ai oublié quelque chose) et j'obtiens une estimation honnête.
Je tiens un tableau de suivi de mon temps de travail depuis deux ans, et il me permet d'affirmer ceci. Les tâches que j'ai décomposées à l'avance se terminent généralement dans les limites de l'estimation, voire plus vite. Les tâches sans décomposition prennent en moyenne deux à trois fois plus de temps.
Ce qu'il faut en retenir
Si vous avez parfois un blocage face à une tâche, essayez quelque chose de simple :
- Fermez votre éditeur de code. Ouvrez une note texte.
- Notez l'objectif en une ligne : ce que vous voulez obtenir au final.
- Détaillez 8 à 15 étapes jusqu'au moment où l'étape suivante se résume à « ouvrir le fichier et écrire X ».
- Au fil de la rédaction, notez les questions et les inconnues sous forme de points séparés.
- Une fois la liste prête, envoyez les questions à ceux qui peuvent y répondre (le client, le lead technique, la documentation). Ne restez pas bloqué sur ces questions : commencez par les points indépendants.
- Ouvrez l'éditeur et travaillez en suivant la liste.
Après cinq tâches menées selon ce processus, vous ne resterez plus bloqué. Au bout de vingt tâches, vous apprendrez à estimer les délais plus honnêtement que 80 % des développeurs qui « estiment à vue de nez ».
Et le plus important. Ce n'est pas une question de productivité. C'est la possibilité de travailler sereinement, sans avoir l'impression de se noyer dans l'inconnu.
Et ensuite
Vous avez un produit à construire sans releases à rallonge ni chaos dans le code ? Estimez les délais ou écrivez-nous : nous décortiquerons votre projet avant qu'il ne se transforme en un sprint de trois mois.

