Ce qui agace le plus quand on développe avec l'IA, c'est ce moment où l'on sait qu'on va créer une tâche, puis devoir parfois patienter jusqu'à ce qu'elle soit livrée avant de demander à notre IA préférée de s'attaquer à la suivante.
Du coup, on note la suite du programme dans un coin… ou pas, et on finit par perdre la moitié du contexte en route.
Avec Singularity, deux mécanismes permettent d'écrire sans jamais s'arrêter. Ils répondent à la même question — « comment je continue à réfléchir pendant que l'IA travaille ? » — sous deux angles complémentaires.
Les dépendances : enchaîner sans attendre
L'idée de départ est simple : on peut poser qu'une tâche ne démarre pas tant que la précédente n'est pas terminée. On rédige le ticket A, puis le ticket B, et on déclare que B dépend de A.
Dans le flow, ça change tout. Plutôt que de rester devant l'écran à guetter la fin de A pour rédiger B, on vide sa tête d'une traite : A, B, C, D, dans l'ordre où ils doivent s'enchaîner. Singularity laisse B en attente, le déclenche dès que A est livré, et ainsi de suite. La file se déroule d'elle-même, dans le bon ordre, sans qu'on ait à revenir la relancer à la main.
Quand l'IA détecte la dépendance que vous avez oubliée
Le plus précieux, c'est ce qui se produit quand on oublie de préciser la dépendance.
On écrit deux tickets à la suite, convaincu qu'ils sont indépendants. Sauf que le ticket B suppose une API, un écran ou une migration qui n'existent que dans le ticket A. Singularity le repère et signale que le ticket B sera compliqué à traiter sans le ticket A… qui en devient la dépendance.
Quand Singularity vous prévient qu'un ticket en suppose un autre, c'est qu'il a lu les deux et compris que le second s'appuie sur quelque chose que le premier doit livrer d'abord. Vous gardez la main : vous validez la dépendance proposée, ou vous l'écartez. Mais vous ne découvrez plus le blocage au pire moment — en plein milieu de l'exécution, quand l'agent bute sur ce qui n'existe pas encore.
Les tickets parents : découper une tâche trop grosse
Le second mécanisme agit en amont. Notre application préqualifie chaque ticket qu'elle reçoit. Cette préqualification sert notamment à découper une tâche trop grosse — comme en agilité — pour la traiter en plusieurs passes.
Pourquoi découper ? Parce qu'une tâche énorme produit un gros commit illisible, un agent qui se disperse et un résultat pénible à relire. En la cassant en sous-tickets, on récolte des commits séparés, un contenu plus propre, et chaque morceau garde une taille que l'IA traite proprement, en une seule passe.
Un ticket parent n'est donc pas qu'une simple étiquette : c'est une tâche-mère qui se résout à travers ses enfants. Et la préqualification ne s'arrête pas là — elle peut aussi rendre les sous-tâches dépendantes les unes des autres. Les deux mécanismes se rejoignent : le découpage crée l'ordre, les dépendances le font respecter.
Pourquoi ça change le flow
Mis bout à bout, dépendances et tickets parents éliminent le temps mort qui grignote le travail avec l'IA. On ne s'arrête plus pour attendre, on n'ouvre plus de notepad parallèle, on ne perd plus le contexte entre deux idées.
On pense le programme en entier, on l'écrit en entier, et Singularity se charge de l'ordonnancer et de l'exécuter dans le bon ordre. L'IA travaille pendant qu'on réfléchit à la suite — au lieu de l'inverse.
Foire aux questions
Qu'est-ce qu'une dépendance entre tickets dans Singularity ?
C'est une règle qui empêche un ticket de démarrer tant qu'un autre n'est pas terminé. On déclare que le ticket B dépend du ticket A : Singularity garde B en attente et le lance automatiquement dès que A est livré. Cela permet d'écrire toute une suite de tâches d'un coup sans rester devant l'écran.
Que se passe-t-il si j'oublie de déclarer une dépendance ?
Singularity lit les tickets et détecte quand l'un suppose un autre. Si le ticket B s'appuie sur une API, un écran ou une migration livrés par le ticket A, l'application signale que B sera compliqué à traiter sans A et propose A comme dépendance. Vous restez libre de valider ou d'écarter la suggestion.
Qu'est-ce qu'un ticket parent ?
C'est le résultat de la préqualification : quand une tâche est trop grosse, Singularity la découpe en sous-tickets — comme en agilité. La tâche-mère se résout à travers ses enfants, ce qui donne des commits séparés, un contenu plus propre, et des morceaux assez petits pour que l'IA les traite proprement en une passe.
Faut-il déclarer les dépendances manuellement ?
Non, pas forcément. Vous pouvez les déclarer vous-même quand vous savez qu'un ticket en bloque un autre, mais Singularity les détecte aussi automatiquement à la préqualification — y compris entre les sous-tickets d'un même ticket parent.
Singularity, le produit maison de Meteor Factory
Singularity est l'environnement de développement agentique conçu et utilisé au quotidien par Meteor Factory. Découvrez Singularity et testez-le gratuitement sur singularity.meteorfactory.dev.