YYLO

Introduction

YYLO coordonne les agents de codage de l'intention d'ingénierie jusqu'au code validé, en préservant des preuves durables de chaque tâche, session, revue et évaluation. Alors que le code généré par l'IA devient la norme, les équipes doivent comprendre comment les agents de codage ont travaillé, quelles décisions ils ont prises et si le code validé correspond à l'objectif initial. YYLO transforme le travail des agents en enregistrements d'ingénierie inspectables. Gérer les agents de codage avec des preuves claires est essentiel, et YYLO offre aux équipes un moyen structuré de superviser les agents de codage du début à la fin, renforçant la confiance dans le développement automatisé et soutenant l'ingénierie agentique avec responsabilité.

---

Qu'est-ce que YYLO ?

YYLO (prononcé « why-lo ») est un système de travail open source conçu pour l'ingénierie agentique. Il coordonne les agents de codage de l'intention au code validé, rendant l'ensemble du processus inspectable et révisable. L'outil enregistre les définitions de tâches, la provenance de session, les preuves de revue et les résultats d'évaluation dans Git, afin que les équipes puissent voir exactement ce qui s'est passé et pourquoi.

Le problème central que YYLO résout est la responsabilité. De nombreuses équipes utilisent des agents de codage pour générer du code, mais le résultat arrive souvent sans contexte ni preuve d'exactitude, et elles n'ont aucun moyen facile d'auditer ce que ces agents de codage ont produit. YYLO résout ce problème en liant chaque tâche à un résultat délimité unique, en acheminant le travail vers un agent de codage spécifique, en validant les résultats avec des tests et des revues encadrées par des politiques, et en stockant des reçus durables dans Git.

L'ingénierie agentique devient rapidement un flux de travail standard. Alors que les organisations délèguent davantage de travail à l'IA, elles ont besoin de boucles de contrôle qui maintiennent les agents de codage alignés sur les objectifs produit. YYLO ne remplace pas Git ni votre flux de travail de dépôt ; il coordonne l'exécution des agents et rend le travail qui produit le code inspectable. Avant tout, l'ingénierie agentique nécessite des outils qui offrent structure, preuves et contrôle—exactement ce que YYLO fournit.

Fonctionnalités clés de YYLO

Les fonctionnalités clés de YYLO se concentrent sur la transparence, le contrôle et la vérifiabilité des agents de codage au sein d'un système d'ingénierie agentique.

Définir l'intention explicitement

Chaque tâche dans YYLO enregistre un résultat délimité unique, ses contraintes et ses dépendances. Cela donne aux agents de codage des limites claires avant le début de toute exécution et empêche l'élargissement non maîtrisé du périmètre.

Déléguer l'exécution avec provenance

YYLO achemine le travail vers un agent de codage sélectionné et préserve l'arborescence de travail, le modèle et la provenance de session. Les équipes peuvent retracer exactement quel agent a fait quoi, avec quel modèle et dans quelle session.

Valider les résultats avec des preuves

Les tests, les reçus de preuves et les revues encadrées par des politiques rendent l'acceptation inspectable. Au lieu de faire confiance aveuglément aux résultats, les équipes vérifient que le code validé répond aux exigences initiales de la tâche.

Tout enregistrer dans Git

Les réponses aux tâches, les commits, les preuves de revue et les résultats de fusion restent durables dans Git via la couche Ledger. Cela rend chaque modification révisable et crée une mémoire d'ingénierie fiable pour les futurs travaux avec des agents de codage.

Gérer les dépendances de tâches

YYLO suit la vérité des tâches et les dépendances dans Git, aidant les équipes à coordonner les agents de codage sans dupliquer les efforts ni perdre le contexte entre les sessions.

Comparer les tentatives des agents

Grâce aux preuves de benchmark conservées, les équipes peuvent comparer la façon dont différents agents de codage ont traité la même tâche. Cela favorise de meilleures décisions d'ingénierie agentique concernant l'agent ou le modèle à utiliser.

Cas d'utilisation de YYLO

Modifications de code IA contrôlées

Une équipe souhaite ajouter la navigation au clavier à une application. Elle définit une tâche délimitée dans YYLO, délègue l'exécution à un agent de codage et valide le résultat avec des tests avant de fusionner. L'ensemble du processus est enregistré comme preuve.

Gestion de flux de travail multi-agents

Lorsque plusieurs agents de codage travaillent simultanément sur le même dépôt, YYLO isole les arborescences de travail et préserve la provenance de session. Cela évite les conflits et maintient la clarté de la contribution de chaque agent de codage.

Construire une mémoire d'ingénierie

Les équipes utilisent YYLO pour accumuler des preuves de tâches, de sessions et d'évaluations au fil du temps. Cela transforme le travail IA dispersé en un enregistrement d'ingénierie durable qui soutient les futures décisions d'ingénierie agentique. Cela aide également les équipes à comprendre quels agents de codage performent bien sur le long terme.

Évaluations reproductibles des agents

Les équipes peuvent comparer les agents de codage à des cas de référence pour voir quel agent produit le code le plus fiable. YYLO Benchmark isole les exécutions et préserve les preuves d'évaluation pour un examen ultérieur.

Comment utiliser YYLO

L'utilisation de YYLO pour coordonner les agents de codage commence par un simple changement :

1. Installez la CLI globalement : npm install -g @yylo/[email protected]
2. Initialisez une tâche délimitée : yy init --task "Add keyboard navigation" --subagent piintent
3. Laissez l'agent de codage s'exécuter dans une arborescence de travail isolée avec provenance de session.
4. Validez le résultat à l'aide de tests et de preuves de revue.
5. Inspectez ce qui s'est passé grâce aux enregistrements de tâches, de sessions et de commits préservés.

Cette boucle simple offre aux équipes un moyen reproductible de coordonner les agents de codage tout en documentant chaque étape. L'objectif est de rendre les agents de codage productifs et responsables, pas seulement rapides. C'est un point de départ pratique pour toute équipe qui explore l'ingénierie agentique pour la première fois.

Public cible de YYLO

• Équipes d'ingénierie qui utilisent des agents de codage en production et ont besoin de responsabilité
• Responsables techniques qui souhaitent du code généré par l'IA révisable provenant d'agents de codage
• Équipes DevOps à la recherche de flux de travail d'ingénierie agentique structurés
• Ingénieurs qualité qui souhaitent vérifier la sortie des agents de codage
• Contributeurs open source qui veulent des processus d'agents transparents
• Startups construisant des pipelines de développement assistés par l'IA

YYLO est-il gratuit ?

YYLO est open source. La version actuelle est la 0.2.1-rc.1 et est disponible via npm sous le scope @yylo. Les équipes peuvent installer et utiliser YYLO pour coordonner des agents de codage sans frais de licence. Comme le projet est encore à un stade précoce de release candidate, les utilisateurs doivent consulter https://yylo.dev pour les mises à jour, la documentation et tout futur changement de tarification. Parce qu'il soutient l'ingénierie agentique sans frais, YYLO est attrayant pour les équipes qui expérimentent le développement piloté par l'IA.

Avantages et inconvénients de YYLO

Questions fréquemment posées sur YYLO

Que fait exactement YYLO ?

YYLO coordonne les agents de codage de la définition de la tâche jusqu'au code validé. Il capture les réponses aux tâches, la provenance de session, les résultats de revue et les preuves de commits pour rendre le travail des agents entièrement inspectable dans un flux de travail d'ingénierie agentique.

YYLO remplace-t-il Git ?

Non. YYLO fonctionne avec Git et stocke la vérité des tâches, les dépendances, les revues et les preuves de fusion directement dans le dépôt. Il complète les flux de travail Git au lieu de les remplacer, offrant aux agents de codage une structure au sein des pratiques Git existantes.

YYLO est-il prêt pour la production ?

La version actuelle, 0.2.1-rc.1, est une release candidate. Elle est disponible pour une utilisation réelle, mais les équipes doivent évaluer les fonctionnalités et s'attendre à des améliorations continues. Les premiers adoptants des outils d'ingénierie agentique doivent surveiller le changelog officiel.

Comment YYLO valide-t-il le travail des agents ?

YYLO utilise des tests, des reçus de preuves et des revues encadrées par des politiques pour valider la sortie des agents de codage. L'acceptation devient inspectable car les étapes de validation sont enregistrées aux côtés du code candidat.

YYLO peut-il fonctionner avec différents agents et modèles ?

YYLO est conçu pour déléguer des travaux délimités à travers les agents et les modèles. Il préserve l'arborescence de travail, le modèle et la provenance de session pour chaque exécution, afin que les équipes puissent comparer les agents de codage équitablement. Les intégrations spécifiques aux fournisseurs doivent être vérifiées dans la documentation officielle.

Qu'est-ce qu'un Engineering Change dans YYLO ?

Un Engineering Change est l'enregistrement stratégique que YYLO construit pour relier l'intention, les décisions, les tentatives, le code validé et, éventuellement, les résultats concrets. Cela aidera les équipes à raisonner sur les agents de codage à un niveau d'abstraction plus élevé. Il s'agit d'une orientation produit, pas d'une affirmation concernant la version actuelle.

Tags YYLO

agents de codage, ingénierie agentique, système open source, coordonner des agents de codage, code validé, provenance de session, flux de travail d'ingénierie IA, outil de coordination d'agents, preuves de tâches, YYLO CLI, mémoire d'ingénierie, outils pour développeurs