Méthode · Comment nous construisons

Nous prouvons que le code fonctionne.

La plupart des agences espèrent que leur code fonctionne. Nous faisons tourner de la vérification mathématique, de la détection de drift entre spec et code et 8+ tests destructifs par fonction — avant qu'une seule ligne n'atteigne la production. C'est pourquoi nos systèmes ne paniquent pas à trois heures du matin.

Pipeline · Spec → Allium → Plan → Impl → Playwright → TLA+
Vérification
TLA+ formel · drift Allium · Playwright destructif
Stack
.NET · ASP.NET Core · React · Blazor · TypeScript · SQL Server · Postgres · SQLite · Docker Swarm · Azure · Semantic Kernel
Couverture
1:1 fonctionnel + 8 destructifs par surface
IA-augmenté
Claude Code · registre de specs · auto-hooks
En production
6 systèmes live sur live4.se · tous en démo ouverte

« Nous travaillons en agile » est la chose la plus dépourvue de sens que l'on puisse dire du développement logiciel en 2026. Tout le monde le dit. Personne ne peut montrer ce que ça veut dire. Ce n'est pas un processus — c'est une plaque qu'on accroche au mur après un stand-up quotidien.

Notre méthode est auditable. Elle laisse des artefacts — fichiers de spec, rapports Allium, modèles TLA+, rapports Playwright — que l'on peut lire et contre lesquels on peut argumenter. Elle attrape les race conditions avant qu'elles n'atteignent la production, le drift entre spécification et implémentation avant que quiconque ne se demande pourquoi le code et la documentation ne s'accordent plus, et les transitions d'état illogiques avant qu'un utilisateur final ne les découvre pour nous.

Le pipeline n'est pas un secret. Il tourne sur chaque modification non triviale dans chaque système que nous opérons. Ci-dessous : ce que fait chaque phase, pourquoi elle existe, et ce que cela signifie en pratique.

Nous ne construisons pas plus de fonctionnalités que le client n'en a besoin. Ce qui est construit a une logique démontrable derrière.

Le pipeline en six phases.

Chaque phase produit des artefacts lisibles par des humains et vérifiables par des machines. Pas de saut de phase, pas de raccourcis. Les phases se déroulent dans l'ordre sur chaque modification non triviale — qu'il s'agisse d'un nouveau champ sur un formulaire ou d'un nouveau modèle de domaine.

Phase 01

Spécification.

Nous écrivons ce que le système doit faire avant de décrire comment. Un fichier de spec par fonctionnalité, revu avant qu'une ligne de code ne soit écrite. Plus une passe de clarification qui attrape les trous qui apparaîtraient sinon en production.

/specify · /clarify
Phase 02

Spec formelle (Allium).

La spec est formalisée en Allium — un langage d'interrogation de spécifications. Incohérences et ambiguïtés remontent comme questions ouvertes avant l'implémentation. Plus tard, la spec est comparée au code pour détecter le drift.

/allium:elicit
Phase 03

Plan + tâches.

La spec est décomposée en un plan et une liste de tâches ordonnée par dépendances. Vient ensuite une phase d'analyse qui applique automatiquement toutes les remédiations recommandées. L'implémentation démarre sur un plan entièrement instrumenté, pas sur un patchwork d'idées.

/plan · /tasks · /speckit.analyze
Phase 04

Implémentation.

Le code est écrit contre le plan — pas au sens abstrait, mais tâche par tâche. Backend d'abord comme principe, pas comme slogan : toute l'autorisation, l'audit, le soft-delete et l'idempotence sont enforced côté serveur. Le frontend est une fine couche de vue.

.NET · React · EF Core · SSE
Phase 05

Tests navigateur.

Couverture fonctionnelle 1:1 — douze fonctions donnent douze tests. Plus huit tests destructifs par surface : XSS, injection SQL, contournement d'auth, race conditions, entrée invalide, valeurs limites. Tous en Playwright. Pas de « happy path ».

Playwright · Fonctionnel + destructif
Phase 06

Vérification formelle (TLA+).

Les machines à états sont modélisées en TLA+ et les invariants démontrés mathématiquement. Le vérificateur de modèles TLC trouve les race conditions, les deadlocks et les états auxquels personne n'a pensé. Ce qui sort de cette phase n'est pas un test qui « passe » — c'est une preuve.

TLA+ · TLC · Invariants

Ce que font la plupart. Ce que nous faisons.

Une comparaison honnête avec ce que nous trouvons en reprenant un système construit par quelqu'un d'autre. Ce n'est pas une attaque — juste un calibrage de ce que « prêt pour la production » signifie réellement.

Tests

Clic manuel avant release.

Agence classique. Quelqu'un clique sur le système, voit que rien n'explose, et appuie sur deploy. Les cas limites sont découverts par le client.

Manuel · Pensée magique
Tests

1:1 fonctionnel + 8 destructifs.

Nous. Chaque fonction implémentée a au moins un test Playwright. Plus huit tests destructifs par surface qui tentent de casser le système des six manières les plus courantes.

Playwright · Auditable
Spec

La spec vit dans un document Confluence.

Agence classique. La spec est écrite une fois, puis dérive loin du code. Six mois plus tard, personne ne sait répondre à « pourquoi ça marche comme ça ? ».

Drift · Oubli
Spec

Drift Allium entre spec et code.

Nous. Spec et code sont comparés automatiquement. Le drift remonte comme questions ouvertes, pas comme suppositions. La spec est du code source — versionnée, revue, toujours synchronisée.

Allium · Détection de drift
État

Race conditions trouvées en production.

Agence classique. Une machine à états est griffonnée au tableau, puis codée à la volée. Les race conditions sont attrapées par un utilisateur malchanceux un jeudi après-midi.

Tableau · Espoir
État

TLA+ démontre les invariants.

Nous. Les machines à états sont modélisées formellement, les invariants démontrés. TLC trouve la grappe d'états que la logique ne gère pas — avant qu'elle ne devienne un incident de production.

TLA+ · Démontrable

La stack — ce que nous choisissons et pourquoi.

Peu de choix techniques, faits une fois, approfondis sur dix ans. Nous ne changeons pas de stack à chaque sprint. Nous changeons quand il y a une vraie raison — et nous la justifions par écrit.

Backend

.NET · ASP.NET Core.

Un runtime mûr, rapide, gratuit avec un système de types fort. EF Core avec des SaveChanges interceptors qui capturent l'audit-trail de façon centralisée — aucun code ne se faufile. Nous écrivons du .NET depuis la version 1.1.

.NET · EF Core · ASP.NET
Frontend

React · Blazor quand ça convient.

React par défaut pour les nouveaux frontends — server components, suspense, streaming natif. Blazor WASM pour les PWA quand C# end-to-end en vaut la peine. Jamais de religion SPA : nous choisissons selon le système.

React · Blazor WASM · TypeScript
Base de données

SQLite. Même en production.

SQLite sur NFS accueille plusieurs projets sans cérémonie tenant_id. Les sauvegardes sont des fichiers à zipper. Aucun coût d'exploitation pour un serveur de base séparé. Nous passons à PostgreSQL le jour où la charge l'exige — rarement avant.

SQLite · WAL · NFS
IA

LLM auto-hébergé en fail-open.

Un modèle local dans le cluster Docker Swarm. Si l'IA est tombée, le système continue de fonctionner sans bloqueur — l'auto-catégorisation devient manuelle, rien ne plante. Compatible RGPD car les données ne quittent jamais le cluster.

LLM local · Semantic Kernel · RAG
Exploitation

Docker Swarm sur Azure.

Nous possédons toute la chaîne : architecture, base, frontend, exploitation. Notre propre cluster Swarm sur live4.se. Pas de services managés à la tarification opaque. Tu sais exactement ce qui tourne, et où.

Docker Swarm · Azure · live4.se
Outils

Claude Code · registre de specs.

Développement IA-augmenté avec hooks déterministes. Un registre de specs comme source de vérité pour ce qui se construit ensuite. Des hooks de pipeline qui bloquent tout travail sans spec. L'IA suit une méthode que nous avons écrite, revue et versionnée.

Claude Code · Hooks · Subagents

L'ensemble des compétences.

Nous choisissons peu de technologies par système — mais la liste de ce que nous maîtrisons vraiment est plus longue. 25+ années de livraisons donnent une base large quand le problème ne colle pas à la solution standard.

Backend

L'écosystème .NET.

.NET 6–10 · C# · ASP.NET Core · .NET Aspire · EF Core · Dapper · MediatR · Quartz.NET · SignalR · gRPC · GraphQL · REST · Clean Architecture · CQRS · DDD · SaaS multi-tenant · microservices · Node.js

Frontend

Web et mobile.

TypeScript · JavaScript · React · React Native · Expo · Next.js · Vue · Svelte · Blazor WASM · Blazor Server · HTMX · Tailwind · Bootstrap · jQuery · HTML · CSS · WordPress · Android (Java) · iOS (Obj-C)

Bases de données

Relationnel, document, recherche.

SQL Server · T-SQL · PostgreSQL · pgvector · pg_trgm · MySQL · MongoDB · Redis · SQLite · Elasticsearch · optimisation des index · stratégies de sauvegarde · execution plans · migrations de schéma

IA & vérification formelle

Agents, RAG, logique démontrable.

Semantic Kernel · Microsoft Agent Framework · Azure OpenAI · Ollama · LLM locaux · Claude Code · Cursor · GitHub Copilot · RAG · embeddings · recherche hybride (pgvector + pg_trgm) · TLA+ · Allium · développement spec-driven · custom skills

Cloud (Azure)

Services que nous utilisons.

App Service · Functions · Container Apps · Service Bus · Event Grid · SQL · Storage · Key Vault · API Management · Entra ID · Monitor · App Insights

Conteneurs & infra

Ops, virt, réseau.

Docker · Docker Swarm · Docker Compose · Kubernetes · Linux (Ubuntu/Debian) · Windows Server · Active Directory · DNS · IIS · Nginx · virtualisation · ferme GPU

CI/CD & tests

Pipelines et points de contrôle.

Azure DevOps · GitHub Actions · BitBucket · Bicep (IaC) · xUnit · NUnit · Playwright · Testcontainers · tests de charge k6 · revue de code · pull requests · Git/GitHub

Sécurité & identité

Auth, RGPD, accessibilité.

OAuth2 · OpenID Connect · JWT · WebAuthn · Passkeys · RGPD · Zero Trust · piste d'audit · soft-delete · idempotency-keys · WCAG 2.1 AA

Intégrations & data

Paiement, communication, gouvernance des données.

Stripe · Swish · Twilio · Mailjet · Google APIs · Fortnox · SCORM · OpenTelemetry · Prometheus · Grafana · gouvernance des données · catalogue de données · gestion des métadonnées · modélisation conceptuelle · qualité des données

La version longue.

Pour qui veut la profondeur technique — voici ce que chaque phase produit réellement, pourquoi elle existe et comment elle s'enchaîne à la suivante. Globalement : le pipeline est une chaîne d'artefacts où chaque phase prend en entrée un document de la phase précédente et produit un nouveau document que la phase suivante peut lire. Aucune passation orale. Pas de « je crois qu'on en a parlé au stand-up de mercredi ».

Allium — le drift comme donnée.

Allium est un langage d'interrogation : tu écris une spécification, puis une passe d'elicitation trouve les trous, les ambiguïtés et les incohérences. Elle produit des questions ouvertes auxquelles il faut répondre avant d'avancer. Plus tard, une passe de distillation compare le code fini à la spec — le drift remonte en trois catégories : spécifié-mais-non-implémenté, implémenté-mais-non-spécifié, et drift comportemental. Chaque élément reçoit une décision individuelle : corriger maintenant, defer (suivre dans la spec) ou dismiss avec raison. Pas de décisions de groupe pour « voir plus tard » — chaque finding a un propriétaire et une date.

TLA+ — des preuves, pas des tests.

Un test qui passe montre qu'une exécution a fonctionné. Il ne dit rien des exécutions que tu n'as pas testées. TLA+ modélise le système comme un espace d'états et fait un parcours exhaustif — le vérificateur de modèles TLC essaie toutes les séquences possibles d'événements et trouve les états où les invariants sont brisés. Pour la gestion d'affaires : un dossier peut-il être à la fois clos et en cours ? Pour SSE : que se passe-t-il si le client se reconnecte en plein milieu d'une mise à jour ? Pour l'idempotence : que se passe-t-il si la même clé d'idempotence arrive dans deux requêtes simultanées ? TLC répond mathématiquement, pas en probabilité.

Tests destructifs — six catégories.

Les tests fonctionnels vérifient que le chemin heureux marche. Les tests destructifs vérifient que le système ne s'effondre pas quand quelqu'un tente de le casser. Nous exécutons au moins huit scénarios destructifs par surface, répartis sur six catégories.

La validation d'entrée bombarde les champs avec des chaînes trop longues, des caractères invalides, des null et des valeurs vides. L'autorisation tente de lire et écrire des ressources que l'utilisateur ne possède pas. La catégorie injection injecte du XSS dans les champs texte et du SQL dans les paramètres de recherche. Les race conditions forcent deux clients à modifier la même ressource dans la même seconde. Les valeurs limites éprouvent longueurs maximales, comptes maximaux et pagination sur la dernière page. La corruption d'état envoie des modifications dans le mauvais ordre ou sur des ressources déjà supprimées.

Rien de tout cela n'est théorique. Chaque catégorie a attrapé de vrais bugs dans des systèmes en production que nous avons construits — avant qu'ils ne sortent.

Développement IA-augmenté — sans religion de l'IA.

Claude Code est utilisé comme outil, pas comme remplacement. Le pipeline ci-dessus n'est pas généré par IA — il est documenté, versionné et appliqué via des hooks déterministes. Les hooks bloquent le travail de feature sans spec, exigent une clarification avant le plan, lancent l'elicitation Allium avant l'implémentation et refusent de livrer une feature sans validation Playwright et TLA+. L'IA suit la méthode — elle ne l'invente pas. Résultat : la vitesse de l'IA avec une revue humaine sur les décisions d'architecture.

Cette méthode prend plus de temps la première semaine. Elle fait gagner des mois quand le système a un an.

Nous ne sommes pas le bon choix pour tout.

Nous reviendrons avec une évaluation de l'adéquation — et si ce n'est pas nous qu'il vous faut, nous le dirons franchement.

Écrivez-nous un mot sur ce que vous essayez de bâtir.

Écrivez-nous