Symfony a très vite adopté cette nouveauté. On les utilise aujourd'hui partout : pour configurer les routes, ajouter des contraintes de validation ou déclarer des listeners.

Dans cet article, nous allons voir comment créer et ajouter un attribut PHP personnalisé sur un contrôleur pour lui injecter un comportement automatique, comme du logging.

1. Créer un attribut

La première étape consiste à créer une classe PHP classique. Pour indiquer qu'elle servira d'attribut, on lui ajoute elle-même l'attribut natif #[\Attribute] :

namespace App\AuditLog;

use Psr\Log\LogLevel;

#[\Attribute(\Attribute::TARGET_METHOD | \Attribute::TARGET_CLASS)]
class Loggable
{
    public function __construct(
        public string $level = LogLevel::INFO,
    ) {
    }
}

Les paramètres du constructeur sont optionnels. Ils permettent de passer des options au moment où on utilise l'attribut. Ici, notre propriété $level sert à définir le niveau de log souhaité.

2. Utiliser l'attribut sur un contrôleur

Une fois notre classe créée, nous pouvons l'appliquer directement sur un contrôleur, soit sur la classe entière, soit sur une méthode (action) spécifique :

namespace App\Controller;

use App\AuditLog\Loggable;
use Psr\Log\LogLevel;
use Symfony\Bridge\Twig\Attribute\Template;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Routing\Attribute\Route;

#[Loggable()]
final class HomepageController extends AbstractController
{
    #[Loggable(LogLevel::CRITICAL)]
    #[Route('/', name: 'app_homepage')]
    #[Template('homepage/index.html.twig')]
    public function index(): void
    {
    }
}

Ici, la méthode index hérite de la configuration par défaut de la classe, et ajoute un nouveau niveau de log plus critique (CRITICAL).

3. Créer le listener pour activer le comportement

Pour que notre attribut serve à quelque chose, il faut intercepter l'appel du contrôleur. Symfony déclenche l'événement ControllerEvent juste avant d'exécuter l'action d'un contrôleur. C'est le moment idéal pour vérifier la présence de notre attribut.

Selon votre version de Symfony, l'implémentation est devenue de plus en plus simple.

Avec Symfony 6.2+

On utilise la méthode getAttributes() de l'événement pour récupérer notre attribut et appliquer notre logique :

namespace App\AuditLog;

use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use Symfony\Component\EventDispatcher\Attribute\AsEventListener;
use Symfony\Component\HttpKernel\Event\ControllerEvent;

class LoggerListener
{
    public function __construct(
        private readonly LoggerInterface $logger = new NullLogger(),
    ) {
    }

    #[AsEventListener(priority: -100)]
    public function logSymfony62(ControllerEvent $event): void
    {
        foreach ($event->getAttributes()[Loggable::class] ?? [] as $attribute) {
            $this->logger->log($attribute->level, 'Controller is loggable', [
                'controller' => $event->getController(),
            ]);
        }
    }
}

Avec Symfony 8.1+

Symfony 8.1 a introduit des événements spécifiques aux attributs. Plus besoin de boucler manuellement, l'événement contient directement l'attribut ciblé :

use Symfony\Component\HttpKernel\Event\ControllerAttributeEvent;
use Symfony\Component\HttpKernel\KernelEvents;

class LoggerListener
{
    #[AsEventListener(KernelEvents::CONTROLLER . '.' . Loggable::class, priority: -100)]
    public function logSymfony81(ControllerAttributeEvent $event): void
    {
        $this->logger->log($event->attribute->level, 'Controller is loggable', [
            'controller' => $event->kernelEvent->getController(),
        ]);
    }
}

Avec Symfony 8.2+

La version 8.2 simplifira encore la syntaxe grâce à un attribut dédié (AsControllerAttributeListener) qui cible directement notre classe :

use Symfony\Component\HttpKernel\Attribute\AsControllerAttributeListener;
use Symfony\Component\HttpKernel\Event\ControllerAttributeEvent;
use Symfony\Component\HttpKernel\Event\ControllerEvent;

class LoggerListener
{
    #[AsControllerAttributeListener(ControllerEvent::class, Loggable::class)]
    public function logSymfony82(ControllerAttributeEvent $event): void
    {
        $this->logger->log($event->attribute->level, 'Controller is loggable', [
            'controller' => $event->kernelEvent->getController(),
        ]);
    }
}

Conclusion

Les attributs apportent une grande souplesse à l'écosystème PHP, et Symfony propose des outils parfaits pour les exploiter.

Grâce à eux, vous pouvez ajouter des comportements à vos contrôleurs de manière propre et déclarative, sans polluer vos méthodes avec du code répétitif.

Bien sûr, Symfony intègre déjà nativement des attributs puissants pour gérer la sécurité (#[IsGranted]), le cache (#[Cache]), ou encore le rate limiting (#[RateLimit]). Mais créer vos propres attributs ouvre la porte à des cas d'usage métiers très intéressants :

• Le Feature Flipping (#[FeatureFlag('new-dashboard')]) : pour activer ou désactiver l'accès à une route selon le déploiement progressif d'une fonctionnalité ;
• La télémétrie et l'observabilité (#[TrackActivity('checkout')]) : pour envoyer des statistiques précises à des outils tiers comme OpenTelemetry ou Plausible dès qu'un utilisateur visite une page clé ;
• La transformation de réponse (#[Serialize]) : pour intercepter le retour de vos contrôleurs et le formater automatiquement selon un standard précis (comme le format JSON d'une API spécifique).

Les possibilités n'ont de limite que votre imagination !

Le projet open source qui nous importe aujourd'hui est Castor 🦫, que nous vous invitons à découvrir.

Pour nous aider dans cette tâche, nous avons choisi zizmor. C'est un outil d'analyse statique de code. Il détecte les vulnérabilités dans vos fichiers de configuration de CI et propose souvent des correctifs. Pour faire simple, c'est l'équivalent de PHPStan, mais pour vos workflows.

Une fois installé, une simple exécution (zizmor .) permet de détecter les erreurs de configuration et de les corriger rapidement. Nous avons ainsi amélioré notre sécurité et facilité la maintenance à long terme.

Voici un exemple de rapport généré par l'outil :

error[unpinned-uses]: unpinned action reference
  --> ./.github/actions/cache/action.yaml:48:13
   |
48 |       uses: actions/cache@v5
   |             ^^^^^^^^^^^^^^^^ action is not pinned to a hash (required by blanket policy)
   |
   = note: audit confidence → High
   = note: this finding has an auto-fix
   = help: audit documentation → https://docs.zizmor.sh/audits/#unpinned-uses

help[artipacked]: credential persistence through GitHub Actions artifacts
  --> ./.github/workflows/artifacts.yml:16:9
   |
16 |         - name: Checkout
   |  _________^
17 | |         uses: actions/checkout@v6
   | |_________________________________^ does not set persist-credentials: false
   |
   = note: audit confidence → Low
   = note: this finding has an auto-fix
   = help: audit documentation → https://docs.zizmor.sh/audits/#artipacked

error[github-env]: dangerous use of environment file
  --> ./.github/actions/cache/action.yaml:14:7
   |
14 | /       run: |
15 | |         set -e
16 | |
17 | |         # Should be the same command as the one in tools/static/castor.php
...  |
44 | |         echo cache_dirname_test=$cache_dirname_test >> $GITHUB_ENV
45 | |         echo cache_key_test=$cache_key_test >> $GITHUB_ENV
   | |__________________________________________________________^ write to GITHUB_ENV may allow code execution
   |
   = note: audit confidence → Low
   = help: audit documentation → https://docs.zizmor.sh/audits/#github-env

error[template-injection]: code injection via template expansion
  --> ./.github/actions/install/action.yaml:28:108
   |
28 |       run: composer install --prefer-dist --no-progress --optimize-autoloader --classmap-authoritative ${{ inputs.composer-flags }}
   |       --- this run block                                                                                   ^^^^^^^^^^^^^^^^^^^^^ may expand into attacker-controllable code
   |
   = note: audit confidence → High
   = note: this finding has an auto-fix
   = help: audit documentation → https://docs.zizmor.sh/audits/#template-injection

Un grand nombre d'erreurs peuvent être corrigées automatiquement :

zizmor . --fix=all

Cependant, pour trouver le hash de commit correspondant à un tag, l'outil a besoin d'un token GitHub avec les bonnes permissions. Il convient donc de le relancer avec la variable configurée :

GITHUB_TOKEN=ghp_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX zizmor --fix=all

Ou, si vous utilisez la CLI gh au quotidien :

GITHUB_TOKEN=`gh auth token` zizmor --fix=all

En revanche, zizmor ne gère pas les montées de version majeures des actions. Pour cela, nous utilisons deux autres méthodes.

En local, nous exécutons actions-up. Cet outil détecte les actions utilisées et propose des mises à jour. C'est le composer update de vos workflows.

En CI, nous faisons confiance à Dependabot. Il vérifie régulièrement vos dépendances et ouvre des Pull Requests automatiquement. Voici notre configuration :

version: 2
updates:
    - package-ecosystem: 'github-actions'
      directory: '/'
      target-branch: 'main'
      schedule:
          interval: 'monthly'
      groups:
          github-actions:
              patterns:
                  - '*'
      cooldown:
          default-days: 7

En conclusion, nous vous recommandons vivement d'adopter zizmor. C'est un outil puissant, rapide à prendre en main, qui sécurise vos pipelines et vous fait gagner un temps précieux au quotidien.

Tout savoir sur les satellites

Vous êtes-vous déjà demandé comment Internet arrivait jusqu’à vos téléphones ? Comment, même en pleine montagne, vous pouvez regarder vos vidéos préférées ? La réponse est simple ; les satellites.

Mais savez-vous comment fonctionne un satellite ? Quels en sont les types, et quels sont les grands acteurs qui envoient chaque année des petits vaisseaux tourner au-dessus de nos têtes ?
Beaucoup de questions auxquelles cet article de buttondown.com répond ce mois-ci.

Composé avec l’aide de Tom Nico, de l’ARCEP* et du chercheur Irénée Régnauld, cet article s’exprime dans un discours extrêmement simple à comprendre et très plaisant à lire. Les informations mises en avant, comme les différents impacts de ces appareils et le fait que l’on a envoyé autant de satellites dans l’espace ces trois dernières années que depuis 1957, sont réellement enrichissantes.

Une bonne morale sur l’exploration spatiale, ses promesses de partage et une réalité bien plus contrastée…

* Autorité indépendante française en charge de la régulation des réseaux télécoms

Quand l’air donne l’heure

Depuis plusieurs décennies, l’électronique s’est emparée d’une part très importante de la vie moderne. Quand l’on regarde les outils précurseurs à nos horloges, nos appareils électroménagers, etc., on les juge d’archaïque, historique, même.

Mais s’il existait des alternatives à l’électronique ? C’est la question à laquelle répond cette vidéo de soiboi soft, qui nous présente ce mois-ci une horloge à quatre chiffres et qui fonctionne… à l’air.

Avec l’aide de la logique microfluidique, de membranes en silicone et de la pression de l’air, le créateur nous démontre une véritable ingénierie et une exploration fascinante des formes alternatives de calcul.

Ce qui rend cette vidéo particulièrement intéressante, au-delà du fait que le système est très satisfaisant à regarder, c’est qu’elle montre comment les concepts fondamentaux de l’informatique – comme la logique, la mémoire et le stockage des données – peuvent exister sans électronique.

Choisir l’enseignement à la haine

Perdre son travail, ce n’est pas une mince affaire. Dans une situation pareille, il est compréhensible de laisser exploser sa colère, d’avoir un discours amer et de critiquer ses anciens employeurs.

Et si nous transformions cette colère en quelque chose de plus concret… de plus utile ? Voici l’histoire du licenciement de Vasilios Syrakis, racontée ce mois-ci dans cet article du financianexpress.

Après son licenciement, Syrakis a choisi de publier une vidéo de 38 minutes pour expliquer les systèmes d’infrastructure qu’il a conçus pendant huit ans ; routage réseau, équilibrage de charge, plateformes cloud et outils permettant à des milliers de développeurs de déployer leurs services à grande échelle. L’objectif est simple ; documenter son travail et partager son expérience avec d’autres ingénieurs. Plutôt que de se concentrer sur la perte de son emploi, Syrakis a choisi de transformer son histoire de licenciement en une démonstration de savoir-faire et de transmission de connaissances.

“Vous gaspillez 90% de vos tokens sans le savoir”

Si vous utilisez des IAs de manière quotidienne et gratuite, vous avez sans doute été confronté au blocage journalier imposé par ces dernières.

Avec cette vidéo de Shubham SHARMA, vous serez désormais incollable sur l’utilisation des IAs et la compréhension de leur limite.

En bon instructeur, Shubham commence d’abord ses explications par la définition de ce que sont des « tokens » d’IA, pour ensuite faire la différence entre la limite de message et de token, et expliquer pourquoi les IA deviennent plus lentes, voire même moins intelligentes à l’utilisation.

Shubham surligne ensuite 9 pièges communs classés parmi 3 grandes catégories. Parmi ces pièges, on retiendra surtout que :

– Plus la conversation est longue, plus chaque message coûte cher (car l’IA relit tout l’historique),

– Les réponses verbeuses coûtent plus cher, et qu’il existe des outils, comme Caveman, qui permettent de réduire ces longues réponses,

– Le choix du modèle est important (ne pas utiliser une Ferrari pour aller chercher du pain).

– L’utilisation de fichiers lourds, comme des images ou des PDFs, fait exploser le quota de token. Il est donc préférable d’utiliser du texte.

Et vous, connaissiez-vous ces pièges ?

Le cimetière des IA

Vibe Graveyard est un site qui recense des incidents, des échecs et des « oopsies » liés à l’utilisation excessive, voire imprudence, des intelligences artificielles dans le développement logiciel, les produits numériques, les médias, la santé et même le droit. Il se présente comme un cimetière de projets développés en grande partie par l’IA et avec peu de compréhension ou de validation humaine.

De la petite bourde aux erreurs catastrophiques, vous pourrez y lire des cas réels d’utilisation d’IA ayant parfois entraîné des erreurs juridiques, voire médicales. Un des cas récents concerne par exemple un problème de gestion de stock au sein des enseignes Starbucks, dont l’IA comptait et étiquetait souvent de manière erronée des boissons de base, notamment des types de lait similaires, et omettait parfois complètement certains produits.

L’objectif d’un tel site n’est pas d’offrir une analyse neutre de l’IA, mais de rappeler que l’automatisation ne remplace pas l’expertise technique, la validation et la maintenance logicielle. Une riche archive et un contrepoids très concret au discours enthousiaste entourant l’IA générative.

Pour aller plus loin

Voici les autres liens que vous avez partagés ce mois-ci, bonne lecture !

• Pourquoi il faut donner son sang juste avant les ponts du mois de mai 
• https://wiki.php.net/rfc/bound_erased_generic_types 
• Windows Zero-Days Expose BitLocker Bypasses And CTFMON Privilege Escalation 
• GrimLink.com Finally Live! 
• Microsoft PowerToys – Windows Utilities for Power Users 
• Trafic divisé par trois, agents qui ne cliquent plus : la Google I/O 2026 sonne la fin d’une époque 
• Google I/O 2026 : Google veut reconstruire Internet autour de l’IA 
• La guerre affecte 62% des PME-TPE | LinkedIn 
• https://www.europesays.com/ai/28009/ 

Cet article Satellites, Horloge à air et cimetière des IA est apparu en premier sur Synolia, agence e-commerce, CRM, Data, PIM/DAM, OMS.

Cet article Correcteur orthographique pour Chrome via Gemini nano est apparu en premier sur Game And Me.

Nous avons eu l'honneur de présenter deux sujets, Loïck Piera sur Castor 🦫 et Grégoire Pineau sur Symfony IA.

Les temps forts techniques

Le programme a couvert des thématiques essentielles qui font évoluer nos pratiques au quotidien, et a aussi rappelé quelques bases que nous connaissons bien.

Intelligence Artificielle et Innovation dans Symfony

L'IA a été au cœur de plusieurs échanges, montrant son intégration progressive dans nos outils quotidiens :

Symfony AI et Embeddings : Grégoire Pineau a présenté son retour sur l'utilisation des embeddings dans Symfony pour des recherches et rapprochements sémantiques poussés - nous vous invitons à retrouver notre récapitulatif de Symfony Live où nous en parlions déjà.

Assistance Générative : Florence Cauchy a partagé un guide pratique sur l'intégration de GitHub Copilot et Claude dans nos workflows. Nous partageons ses conseils :

• Mise en place de skills ;
• Définition de guidelines pour les agents ;
• Exploiter aussi bien le CLI que les agents cloud.

Si vous n'avez pas encore d'assistance par LLM pour coder, c'était une bonne introduction !

Outillage, Productivité et Modernisation

Nous avons exploré de nouveaux outils pour optimiser notre productivité :

Castor : Loïck Piera nous a fait découvrir les coulisses de ce task runner open source indispensable 😉 (oui c'est nous qui le développons). L'occasion de parler des outils sur lesquels repose Castor comme symfony/console, et de parler de fonctionnalités peu connues comme :

• Les events pour étendre le fonctionnement ;
• Les imports distants pour utiliser des tasks extérieures ;
• Les remote exécutions, pour lancer des outils sans les installer.

Nous vous invitons à lire les slides qui sont pleines d'informations !

Sidekicks applicatifs : Nicolas Grekas a présenté comment tirer partie de Caddy/FrankenPHP pour faciliter la configuration de nos applications HTTP. Grâce à ces sidekicks, l'application peut continuer à tourner en mode worker (donc sans avoir à redémarrer de 0 à chaque requête, comme c'est le cas avec PHP-FPM) mais en ayant sa configuration à jour :

• côté application, on récupère une valeur de configuration, qui est locale et toujours à jour, grâce à un simple appel à une fonction ;
• un thread tourne à côté pour mettre à jour cette valeur dès qu'il y a un changement (ce thread est setup très simplement dans Caddy / FrankenPHP).

Il aimerait voir cette nouvelle manière de faire devenir un standard dans l'écosystème PHP, à la place du traditionnel php-fpm, afin d'être égaux avec les technos alternatives à PHP comme node, qui proposent des comportement similaires.

Architecture et Qualité du Code

La durabilité logicielle et les bonnes pratiques restent fondamentales :

Qualité avec PHPStan : Vincent Langlet & Étienne Dhennin nous font la présentation de leur mise en place d'un écosystème de qualité chez Weglot. Ils nous ont présenté les différents fixers, linters et outils de tests disponibles et qu'ils ont utilisés, pour répondre à leur définition de la qualité : la capacité d'un système à remplir son rôle aujourd'hui comme demain, au travers de trois dimensions : fonctionnelle, temporelle et humaine. La direction de l'entreprise avait besoin de justifications pour le temps passé à faire de la qualité, et ils ont donc introduit un métrique original : le taux de hotfix en production (et donc oui il a baissé).

Parmi leurs retours d’expérience sur PHPStan en particulier :

• Ne pas générer de baseline sur les projets legacy, prioriser les niveaux "bas" (jusqu’au niveau 5) - nous sommes partagés sur ce point car la baseline permet justement de pouvoir contribuer à des projets legacy avec une analyse statique élevé sur nos nouveaux développements ;
• Privilégier les extensions spécifiques à votre projet (phpstan-doctrine par exemple) aux niveaux 9 et 10, souvent superflus.

API Design Pragmatique : Amaury Bouchard a exploré des alternatives au design d'APIs. Il critique pas mal JWT car ça ne gère pas l'expiration par exemple. Un des points que nous partageons est que HTTP Basic aujourd'hui c'est tout à fait valide et sécurisé (car en HTTPS il n'y a pas de "fuite" des identifiants). Le take-away du talk concerne le choix entre RPC et REST. Vouloir utiliser absolument du REST alors que notre API ne gère pas des états mais des actions est un mauvais choix de design. En résumé :

• RPC pour les API qui font des actions (envoyer un mail, publier des redirections...) ;
• REST pour les API qui modifient des états, le CRUD, etc.

En bref, un appel à la simplicité, quitte à remettre en questions des dogmes acquis depuis très longtemps, de très bons sujets de réflexion lors de votre prochaine conception d’API.

Tests sans Mocks : Imen Ezzine a présenté une solution intéressante pour tester efficacement des APIs externes sans recourir aux mocks - et surtout pour pallier à l'imcompatibilité de PHP-VCR avec le client HTTP de Symfony.

En utilisant le format HAR, un nouveau decorator RecorderHttpClient, et un simple attribut #[UseRecord] sur les fonctions de test (via le bridge phpunit), nous pouvons enregistrer une réponse API, de sorte à pouvoir utiliser plus tard cet enregistrement pour simuler des appels à une API externe. Ainsi, pas besoin de créer un mock ! L’appel est joué réellement une seule fois, puis réutilisé directement au moment de lancer les tests. Un mécanisme permet de configurer son mode d’enregistrement, pour rafraîchir périodiquement, rejouer l’appel à chaque fois ou au contraire le verrouiller.

L’ensemble apparaît comme une solution efficace et très élégante pour s’affranchir d’une problématique que nous avons tous déjà rencontrée. Une PR est soumise sur Symfony 8.2.

Gestion des Exceptions : Smaïne Milianni a récapitulé les meilleures pratiques pour gérer et logguer les exceptions proprement. De bons rappels et peut être même des guidelines à coller dans nos AGENTS.md !

• Relancer systématiquement les exceptions attrapées dans les couches “profondes” de l’application (métier, infra…), pour les gérer uniquement dans les couches d’interface.
• Ne pas catcher la terre entière (catch \Exception) ;
• Ne pas catcher Throwable si on est bas niveau ;
• Ne jamais "rien faire" dans le "catch" (il faut au moins un log) ;
• Utiliser une exception pour faire du contrôle de flow classique (nous sommes un peu partagé à ce sujet aussi - c'est parfois élégant) ;
• Catcher et relancer une exception sans n'avoir rien changé / rien fait : autant de rien catcher ;
• ne jamais oublier l'argument $previous quand on rethrow / mute une exception ;
• créer des exceptions custom, utiliser des constructeurs statiques... pour nos exceptions métier.

Sujets intemporels

Passkeys et WebAuthn : Sylvain Combraque nous a fait un rapide cours historique sur les manières de stocker les mots de passe utilisateurs, du très sécurisé plaintext jusqu'au hashage, sans oublier l'OICD pour nous montrer comment avec le temps, nous avons pu répondre aux questions de sécurité liées à nos systèmes d'authentification. Il nous a finalement expliqué qu'au final, la manière la plus simple de sécuriser nos mots de passe, c'est de ne pas en avoir ! Chose possible aujourd'hui et depuis 2015 grâce aux Passkeys, une solution d'authentification locale, unique par compte, et impossible à faire fuiter. Cela fait 10 ans que nous en entendons parler et que les briques techniques existent, et pourtant, ce n'est toujours pas "grand public" ! Les mots de passe ont encore de beaux jours devant eux... À nous de faire bouger les lignes !

Gotchas PHP : Frédéric Bouchery a animé une session interactive sur les comportements inattendus et les subtilités du langage. Par exemple, saviez-vous que new daTeTimE(); fonctionne aussi bien que new DateTime(); mais que vos constantes elles, sont sensibles à la casse ? C'était une façon très ludique de nous expliquer des principes du langage comme la compilation, les changements de syntaxes...

Conclusion

Au-delà de la technique, l'AFUP Day a été un moment de partage plein d'échanges et riche en apprentissages. Nous sommes vraiment ravis de retrouver un événement à Paris.

Les perspectives ouvertes par l'IA et la modernisation des outils promettent des projets passionnants pour JoliCode. Un grand merci à l'AFUP Paris et à tous les bénévoles pour cette organisation impeccable 👏 Comptez sur nous l'année prochaine !

Ce n'est pas en réunion que j'ai entendu ça. C'est en mission chez un client, dans leurs bureaux. Ce genre de phrase, je l'entends de plus en plus souvent maintenant, entre deux écrans, dans les couloirs, pendant la pause déjeuner. L'IA fait désormais partie du quotidien.

Quelques semaines plus tard, un autre client nous présente deux pages de maquettes générées par Claude, structure de page et premières intentions de contenu, pour expliquer ce qu'il voulait avant même d’ouvrir Figma.

C'est ce constat qui nous a poussés à écrire cet article, pour poser ce que ça change dans notre façon de travailler, et ce qu'on peut en tirer concrètement pour nos projets et nos clients.

Ce que j'ai trouvé en explorant, c'est que l'IA ne remplace pas le designer, elle redistribue son temps et son attention. Certaines tâches s'accélèrent, d'autres disparaissent, et de nouvelles compétences deviennent importantes. La principale d'entre elles, j'y reviendrai, est la capacité à formuler des demandes précises. Savoir parler à une IA, ça s'apprend et ça change tout à la qualité des résultats.

Le prompt : la compétence clé

Avant de parler workflow et processus, un point essentiel, la qualité des résultats dépend de la qualité de la demande. C'est le cœur du sujet.

Un bon prompt, c'est un bon brief. Précis, contextualisé, avec une intention claire et des contraintes définies. L'erreur la plus fréquente, celle que j'ai faite moi-même au début, c'est de rester trop vague en espérant que l'IA devine l'intention derrière la demande.

ex : Prompt trop vague
"Génère un UX flow pour un site e-commerce."

ex : Prompt structuré
"Génère un UX flow pour la page produit d'un site e-commerce de mode féminine, destiné à des femmes de 25–40 ans sur mobile. Inclure : découverte produit, sélection de taille, ajout au panier, paiement, et edge cases (taille indisponible, rupture de stock, code promo invalide). Format en étapes claires avec états d'erreur et micro-interactions.".

La différence se joue sur la précision de la demande. Un prompt efficace s'articule autour de cinq dimensions. Elles font la différence entre un résultat générique et une base vraiment exploitable :

1. La tâche : Ce que l’IA doit faire concrètement, générer un écran, proposer un flow, décliner un composant.
2. Le contexte : Où s'intègre cet écran ou ce parcours dans l'expérience globale ? Quel est l'état précédent ?
3. Les éléments clés du design : Les caractéristiques visuelles ou fonctionnelles importantes que l'IA doit intégrer dans sa proposition.
4. Les comportements attendus : Comment réagissent ces éléments lors de l'interaction (hover, tap, scroll, états vides, erreurs…)
5. Les contraintes : Le support, la mise en page, le style visuel, les guidelines de marque. Plus ces contraintes sont précises, plus le résultat est pertinent.

J'aime les métaphores, alors en voici une : l'IA ressemble à un nouveau collaborateur. Il ne connaît pas encore le contexte, les clients, les process. Sans brief précis, il produit quelque chose de générique. Bien briefé, il va vite et produit une base exploitable.

Apprendre à prompter, c'est apprendre à collaborer avec l'IA, formuler ce qu'on veut, donner le bon niveau de contexte, et itérer ensemble.

Intégrer l'IA à chaque étape

Maintenant qu'on a posé ce cadre, voyons comment ça se traduit dans le travail. J'ai organisé cette exploration en trois phases : explorer, concevoir et produire. L'IA n'y joue pas le même rôle à chaque étape.

Une précision importante avant de commencer : "plus vite" ne veut pas dire "sans effort". Une partie du temps gagné en génération est réinvestie en correction, ajustement et validation. L'IA produit une base et non un livrable.

Explorer plus vite et plus largement

Un brief flou est l'une des principales sources de perte de temps en début de projet. Avant, cela voulait dire plusieurs allers-retours avant même de commencer à concevoir. Aujourd'hui, on peut envoyer le brief tel quel à un agent conversationnel, demander une structure claire avec l'utilisateur cible, le problème, les objectifs attendus et les questions de clarification manquantes, et avoir une base de travail en quelques minutes.

Sur les UX flows, même constat. L'IA est capable de générer rapidement plusieurs scénarios, explorer des alternatives et identifier des états qu'on aurait pu oublier (erreurs, compte vide, connexion perdue..). La décision reste entièrement humaine : simplifier, prioriser, arbitrer.

Concevoir et itérer sans blocage

Pour cette phase de conception, j'ai testé spécifiquement deux outils : Figma Make et Claude Design.

Figma Make permet de générer plusieurs propositions d'écrans à partir d'une description ou de frames, de tester des patterns qu'on n'aurait pas spontanément tentés, et d'explorer des déclinaisons visuelles rapidement. C'est un véritable moteur d'expérimentation. Par défaut, il génère des écrans génériques, sans personnalité, sans cohérence graphique. Cette limite se réduit selon ce qu'on lui fournit un prompt détaillé ou en faisant plusieurs itérations.

Claude Design va plus loin dans l'aboutissement. La richesse de l'interface et la finesse des ajustements possibles sont intéressantes. C'est à ce jour la solution qui produit les prototypes les plus aboutis parmi celles que j'ai testées. Si le prompt semble insuffisant, Claude Design propose automatiquement un questionnaire pour affiner la demande avant de générer.

Autre détail qui a son importance, Claude Design propose deux modes d'itération complémentaires : le chat pour les changements globaux, et les commentaires inline pour les ajustements précis sur un élément spécifique. En pratique, ça permet de générer rapidement des visuels utiles pour aligner une équipe, transformer une idée produit en prototype testable.

Dans les deux cas, ce que ces outils produisent est une base de travail, pas un livrable finalisé. Le designer reste celui qui la transforme en proposition exploitable.

Au-delà des écrans, l'IA change aussi la façon de rédiger les interfaces. Sur le microcopy, ces petits textes qui guident l'utilisateur à chaque étape, c'est une aide précieuse. En définissant le ton et le style de communication de la marque dans le prompt, on peut générer rapidement des textes cohérents pour tous les états d'interface : succès, erreur, chargement, état vide.

Produire et livrer plus efficacement

Le handoff, ce moment où le designer passe le relais au développeur, est souvent un moment de friction. L'IA ne le supprime pas, mais elle le fluidifie. En connectant Figma à Claude via le protocole MCP (Model Context Protocol), Claude peut lire directement la structure du fichier (composants, calques, propriétés…) et produire une base de documentation de specs. C'est une piste que je n'ai pas encore testée personnellement, mais qui mérite d'être mentionnée. La qualité du résultat dépendrait directement de la structure du fichier Figma : un fichier bien nommé avec des composants propres donnerait un résultat exploitable.

C'est d'ailleurs une règle qui vaut pour tout l'article : l'IA amplifie que ce qui est déjà structuré. Un design system solide n'est plus seulement un outil de cohérence visuelle, c'est ce qui rend le travail exploitable par l'IA.

Et côté client, qu’est-ce que ça change vraiment ?

Les deux anecdotes d'introduction ne sont pas des cas isolés, elles disent quelque chose d'important : le niveau de préparation et d'attente des clients change. Quand un client arrive avec des maquettes générées par IA pour illustrer son idée, il ne cherche pas à faire le travail du designer. Il cherche à être compris plus vite, à aligner plus tôt, à éviter les allers-retours.

Pour le designer, ça change la nature de la conversation. On ne part plus d'une page blanche commune, on part d'idées déjà mises en forme, parfois précises, parfois approximatives mais toujours révélatrices de ce que le client a en tête. Le client montre une direction, une intention mais pas une solution. C'est au designer de définir ce qu'il y a derrière.

La prochaine étape naturelle, que j'imagine, c'est l'atelier client en live : générer des variantes d'écrans directement en réunion pour itérer en temps réel sur une direction. L'enjeu est simple : aligner plus vite.

Pour conclure

L'IA transforme réellement la pratique du design. Elle accélère certaines étapes, structure des réflexions qui prenaient du temps, et ouvre des possibilités d'exploration.

Elle ne connaît pas les utilisateurs, leurs habitudes, leurs frustrations, ce qui les fait décrocher. La créativité graphique, la sensibilité visuelle, la cohérence d'une marque, tout cela reste entièrement humain. Mais elle propose des directions qu'un designer seul n'aurait pas explorées, pas parce qu'elles sont meilleures, mais parce qu'elle n'a pas nos biais.

Sur un prochain sujet, nous pourrons approfondir un aspect particulier : comment configurer Claude avec des instructions personnalisées (system prompts, custom instructions) pour lui donner un contexte permanent et des compétences adaptées à la pratique du designer.

Voici ce qu'elles contiennent :

Maîtriser les agents IA pour le développement

La porte d'entrée ! Une journée pour sortir de l'autocomplete et entrer dans le travail avec des agents. Au programme : fonctionnement réel d'un agent (mémoire, contexte, permissions), standardisation des conventions d'équipe via le fichier AGENTS.md (agnostique, fonctionne avec Claude Code, Codex, Cursor), utilisation de l'agent comme QA automatisée avec génération de tests, lecture des logs et boucle d'auto-réparation sous supervision, puis création de commandes personnalisées pour industrialiser chez vous les revues de code, la détection de N+1, de failles XSS, et les patterns propres à votre équipe.

Voir la formation

L'IA pour développeurs frontend, avec Cursor et le Vercel AI SDK

Les deux faces du sujet. Jour 1 côté workflow : Cursor dans ses trois modes (Ask, Plan, Agent), commandes custom, intégration d'outils via MCP, .cursorrules pour que l'agent respecte l'architecture du projet, gestion du contexte sur les sessions longues.

Jour 2 côté produit : construire un vrai assistant avec le Vercel AI SDK (streaming, tool calling, architecture RAG sur vos contenus, typage strict avec Zod), déploiement et les questions qui vont avec (coûts API, monitoring, stratégies de cache).

Voir la formation

Maîtriser l'IA avec Symfony

Pour intégrer l'IA générative dans vos applications Symfony avec la même rigueur que le reste de votre code. On s'appuie sur Symfony/AI, le composant officiel de l'écosystème, auquel on contribue directement.

Socle de 2 jours : fondamentaux des LLM, ChatInterface, typage fort des sorties en objets PHP, RAG complet sur vos documents avec pgvector. Puis deux modules optionnels : le premier transforme votre application en orchestrateur d'agents capables d'appeler votre code PHP et vos APIs internes, le second aborde MCP, le McpBundle, les stratégies de test, le monitoring en production et la maîtrise des coûts.

Voir la formation

Et si vous ne codez pas ?

POs, chefs de projets, dirigeantes et dirigeants de boîte tech : l'IA change aussi la façon dont vos équipes travaillent, à quelle cadence, sur quelle échelle de temps. Notre formation Culture Engineering a un module dédié pour comprendre ce qui bouge pour mieux collaborer avec vos équipes tech.

Pourquoi chez nous ?

On forme sur ce qu'on pratique. Nos projets tournent en production avec ces outils, on contribue directement à Symfony/AI, et on publie sur notre blog ce qu'on apprend. Ces formations vont évoluer avec l'écosystème. Certains modules seront réécrits dans six mois. Un participant d'aujourd'hui peut revenir dans un an sur une session mise à jour, et ce sera la suite logique, pas une répétition 🙂

Toutes nos formations sont certifiées Qualiopi, finançables via les OPCO, et modulables en intra-entreprise. Un doute sur la formation qui correspond à votre équipe ? Écrivez-nous !.

Beaucoup de nos projets (et sans doute les vôtres) reposent encore sur d’anciens frameworks CSS basés sur Sass, comme Bootstrap v4 ou d'autres solutions maison (coucou Atomic Builder 👋). Et soyons honnêtes : maintenir et mettre à jour ces projets relève souvent du parcours du combattant. On fait face à un manque cruel de flexibilité, la dette technique s’accumule, et les dépendances commencent à poser plus de soucis qu'elles n'en résolvent.

Sans oublier que Sass, bien qu’ayant été notre fidèle compagnon pendant de très (très) nombreuses années, devient de moins en moins indispensable avec l'évolution fulgurante du CSS natif. Nous avons d’ailleurs eu l’occasion d’en parler dans notre article expliquant pourquoi passer à PostCSS.

Le choix s'est donc naturellement porté vers Tailwind CSS v4. C'est une solution qui a fait ses preuves chez JoliCode (J'ai testé Tailwind CSS) et, cerise sur le gâteau, cette nouvelle version ne nécessite aucune dépendance liée à Sass.

L’année dernière, nous avons amorcé des phases de migration pour plusieurs de nos projets clients. Aujourd’hui, j’ai envie de partager avec vous quelques retours d’expérience et une méthodologie (testée et approuvée ✅) pour que ces migrations se passent le mieux possible !

Phase 1 : Migration des feuilles de styles CSS 🎨

L’objectif de cette première phase est simple : utiliser du CSS natif et dire officiellement au revoir à notre bon vieux Sass. 👋

La toute première étape consiste à migrer la configuration globale de votre projet (généralement définie dans des fichiers tels que variables.scss ou global.scss) vers un système basé sur des custom properties (variables CSS), en ciblant la racine du document HTML via la pseudo-classe :root.

Avant (Sass) :

$color-primary: #f7d325;
$color-secondary: #ff2951;
$font-family-sans-serif: "Source Sans Pro", sans-serif;

Après (CSS natif) :

:root {
  --color-primary: #f7d325;
  --color-secondary: #ff2951;
  --font-sans: "Source Sans Pro", sans-serif;
}

Cas n°1 : Les variables et fonctions

Une fois votre thème mis en place, votre première mission sera de remplacer tous vos $ par des var(--). C'est aussi l'occasion de traduire vos fonctions Sass en CSS moderne. 👀

Avant (Sass) :

.button {
  width: math.div(100%, 3);
  background-color: $color-primary;
  
  &:hover,
  &:focus-visible,
  &:active {
    background-color: darken($color-primary, 15%);
  }
}

Après (CSS natif) :

.button {
  /* Le CSS natif s'occupe des calculs dynamiquement ! */
  width: calc(100% / 3);
  background-color: var(--color-primary);
  
  &:hover,
  &:focus-visible,
  &:active {
    /* Magie ! Les couleurs relatives en CSS natif */
    background-color: hsl(from var(--color-primary) h s calc(l - 15)); 
  }
}

Aujourd'hui, le CSS natif est devenu suffisamment mature pour remplacer la quasi-totalité des fonctions Sass. C’est particulièrement vrai pour les manipulations de couleurs, qui s’écrivent désormais très simplement grâce aux couleurs relatives en CSS. 🎨

Cas n°2 : Le piège du sélecteur d’imbrication & et du BEM

La bonne nouvelle, c'est que le CSS natif gère désormais très bien le nesting (l'imbrication). L'esperluette (&) pour cibler des états comme &:hover ou &:focus fonctionne parfaitement sans Sass.

La mauvaise nouvelle ? Si vous utilisiez le & pour concaténer des classes, typiquement avec la méthodologie BEM (&__element ou &--modifier), le CSS natif ne comprendra pas cette syntaxe. Il va falloir « désimbriquer » ces éléments.

Avant (Sass) :

.link {
  color: $color-primary;
  
  &:hover,
  &:focus-visible,
  &:active {
    color: $color-secondary;
  }

  /* Sass va compiler ce code en ".link--secondary" */
  &--secondary {
    color: $color-secondary;
  }
}

Après (CSS natif) :

.link {
  color: var(--color-primary);
  
  /* Ce code fonctionne toujours en CSS natif ! */
  &:hover,
  &:focus-visible,
  &:active {
    color: var(--color-secondary);
  }
}

/* Il faut sortir la classe enfant de l'imbrication */
.link--secondary {
  color: var(--color-secondary);
}

Cas n°3 : Les media queries

Pour les media queries générées via des mixins ou des fonctions Sass (du type @include media-breakpoint-up(md)), passez simplement les valeurs en dur pour le moment (@media (min-width: 768px)). Nous nous en occuperons plus tard, lors de l'intégration de Tailwind.

Cas n°4 : Les mixins, boucles et règles complexes

Pour les cas très spécifiques (boucles @for, mixins complexes), la solution la plus pragmatique est de récupérer la version déjà compilée et de la coller dans votre fichier CSS.

Avant (Sass) :

@for $i from 1 through 3 {
  .button--size-#{$i} {
    padding: #{$i}rem;
  }
}

Après (CSS natif) :

.button--size-1 { padding: 1rem; }
.button--size-2 { padding: 2rem; }
.button--size-3 { padding: 3rem; }

À la fin de cette phase, le code CSS de votre projet n'utilise techniquement plus aucune fonctionnalité propre à Sass. 👏

Phase 2 : Migration (provisoire) des classes utilitaires 🧰

C'est l'étape de la « prise de masse » avant la sèche. 💪

L'idée est de récupérer le CSS compilé de toutes les classes utilitaires de votre ancien framework et de les stocker dans un nouveau dossier, par exemple utilities/. Pour garder l'esprit clair, séparez-les par thématique : utilities/typography.css, utilities/spacing.css, etc.

Exemple d'un fichier utilities/spacing.css (récupéré depuis Bootstrap v4) :

.mt-1 { margin-top: 0.25rem !important; }
.mt-2 { margin-top: 0.5rem !important; }
.mb-3 { margin-bottom: 1rem !important; }
/* ... */

Votre CSS global va grossir temporairement. C'est normal, ne paniquez pas ! Ces fichiers agiront comme un filet de sécurité visuel en attendant que Tailwind prenne le relais. 😮‍💨

Phase 3 : On débranche l’ancien framework CSS 💔

Si les phases 1 et 2 ont été faites minutieusement, vous pouvez supprimer l'ancien framework CSS de vos dépendances. Visuellement, rien ne devrait bouger. 🤞

Phase 4 : L'adieu à Sass 🫡

C'est l'heure de désinstaller une fois pour toutes sass (ou node-sass). N’oubliez pas de renommer tous vos fichiers .scss en .css.

Lors de cette étape, il est très probable que le compilateur échoue lors de son premier lancement. Si la console se remplit d'erreurs, pas de panique, c'est un grand classique ! Cela s'explique généralement par l'une de ces trois raisons :

1. L'import fantôme : Votre bundler (comme Webpack) ou votre point d'entrée JavaScript (le fameux app.js) pointe toujours vers un fichier portant l’extension .scss. Pensez à bien mettre à jour vos chemins d'importation.
2. Le reliquat de Sass : Il reste quelques $, @use, etc. qui traînent dans vos fichiers CSS. Pensez à les supprimer.
3. Les commentaires : Les commentaires d'une seule ligne écrits avec // étaient valides avec Sass, mais pas avec votre CSS natif.

L'erreur classique à corriger :

// Ce commentaire était valide en Sass, mais fera planter votre CSS natif !
.element { color: var(--color-primary); }

/* Remplacez-le par la syntaxe standard ! */
.element { color: var(--color-primary); }

Une fois ces petits ajustements faits, respirez un grand coup. Le plus dur techniquement est derrière vous. 🎉

Phase 5 : L'entrée en scène de Tailwind CSS v4 🤩

Il est enfin temps d'installer Tailwind CSS v4 et PostCSS (indispensable dans nos projets Symfony avec Webpack Encore). Je vous conseille de suivre la documentation officielle pour le setup initial.

Le piège de l'import global (et du Preflight)

La documentation officielle vous recommandera d’importer Tailwind de cette façon :

@import "tailwindcss";

En utilisant cet import global, Tailwind embarque par défaut plusieurs layers CSS (theme, base, components et utilities), injectant par la même occasion son propre reset CSS (Preflight). Si votre projet possédait déjà un fichier de reset (comme normalize.css), vous risquez d’avoir des conflits.

Pour cela, privilégiez des imports ciblés (sans les layers CSS) :

@import "tailwindcss/theme.css";
@import "tailwindcss/utilities.css";

La magie de la directive @theme

La révolution de la v4, c'est qu'elle est CSS-first. Fini l'énorme fichier tailwind.config.js à la racine de votre projet ! Le thème que vous aviez anticipé lors de la phase 1 s'intègre désormais presque nativement grâce à la nouvelle directive @theme.

Avant :

:root {
  --color-primary: #f7d325;
  --color-secondary: #ff2951;
  --font-sans: "Source Sans Pro", sans-serif;
}

Après :

@theme static {
  --color-primary: #f7d325;
  --color-secondary: #ff2951;
  --font-sans: "Source Sans Pro", sans-serif;
}

C'est aussi le moment parfait pour utiliser la directive @variant afin d'uniformiser ces fameuses media queries que nous avions mises en dur plus tôt !

Avant :

@media (min-width: 768px) {
  .card {
    color: var(--color-primary);
  }
}

Après :

@variant md {
  .card {
    color: var(--color-primary);
  }
}

Ce petit changement vous garantit que tout votre CSS sur-mesure restera parfaitement synchronisé avec le comportement natif des classes utilitaires de Tailwind.

Phase 6 : Le nettoyage de printemps 🧹

Je préfère être honnête : cette étape demande de la patience. 🙃

L'objectif est de supprimer le dossier utilities/ créé à la phase 2. Pour ce faire, vous allez devoir remplacer dans tous vos templates HTML/Twig les anciennes classes par les nouvelles générées par Tailwind.

Vos meilleurs alliés ici seront l'outil de recherche de votre IDE, les expressions régulières (Regex), et bien sûr votre LLM (Large Language Model) favori (ChatGPT, Claude, GitHub Copilot, etc.) pour automatiser un maximum le processus.

Avant (Bootstrap v4) :

<div class="d-flex flex-column flex-md-row">...</div>

Après (Tailwind CSS v4) :

<div class="flex flex-col md:flex-row">...</div>

Le boss final : Les grilles 😎

Il n'y a pas de solution magique ici. Les vieux frameworks utilisaient généralement Flexbox pour simuler un comportement de grille. Tailwind, lui, utilise le module natif CSS Grid Layout (modèle de disposition en grille).

Il va falloir repasser sur vos grilles manuellement. 😬

L'ancienne approche (Flexbox) :

<div class="row">
  <div class="col-12 col-md-6">...</div>
  <div class="col-12 col-md-6">...</div>
</div>

La nouvelle approche (Grid) :

<div class="grid grid-cols-1 md:grid-cols-2">
  <div>...</div>
  <div>...</div>
</div>

C'est fastidieux, mais le DOM en ressort considérablement allégé et plus lisible. 🥳

Conclusion : Tout ça pour ça ? 🤔

Oui, mille fois oui. Migrer vers Tailwind CSS v4 n'est pas un parcours de santé pour un projet existant. Mais les avantages sont colossaux.

Vous dites adieu à l'usine à gaz qu'était devenu Sass au fil des années. Le poids final de votre CSS sera drastiquement réduit puisque Tailwind ne compile que ce que vous utilisez réellement. Sans parler des performances pures : avec son nouveau moteur écrit en Rust, les temps de compilation sont si rapides qu’on les remarque à peine.

Enfin, la Developer Experience (DX) de vos équipes s'en trouvera transformée. C'est un investissement en temps conséquent, mais c'est un cadeau inestimable que vous faites au futur de votre projet. 🎁

Et concrètement, comment on vend ça à sa direction ?

C'est souvent la question qui fâche. On sait que le chantier est nécessaire, mais il est difficile d'estimer le temps que cela va prendre sans y laisser des plumes, d'où l'effet tunnel qui effraie les équipes produit.

Pour débloquer la situation, nous avons l'habitude chez JoliCode de commencer par un audit flash (1 à 2 jours). L'objectif est de poser les choses à plat pour vous fournir un plan de bataille concret à défendre en interne :

1. Un état des lieux clair de la dette front actuelle (dépendances, risques, obsolescence).
2. Une estimation chiffrée de la migration, découpée par phase.
3. Un plan de déploiement progressif qui ne bloque pas votre roadmap produit.
4. Les bénéfices attendus (gains de performance, vélocité des équipes, etc.).

Si vous avez besoin d'aide pour cadrer votre propre migration, n'hésitez pas à nous faire signe !

J’espère que ce retour d’expérience vous sera utile et vous donnera le courage de sauter le pas. N'hésitez pas à partager vos propres astuces ou vos galères de migration dans les commentaires ! 🙂

1, Donner de la vie à vos applications mobiles

Votre téléphone ne se contente pas d’afficher ou de sonner ; il vit. À chaque notification, message ou appel, une vibration plus ou moins subtile vient accompagner ce que vous voyez sur l’écran.

Ce retour haptique, popularisé notamment par Apple, fait aujourd’hui partie intégrante de l’expérience mobile, en ajoutant une dimension tactile à nos interfaces.

Depuis longtemps, cette fonctionnalité était réservée aux applications natives. Mais aujourd’hui, grâce à des solutions comme Web Haptics, on peut désormais intégrer des vibrations directement dans les navigateurs.

Au-delà de son aspect technique, l’intérêt de Web Haptics réside dans sa capacité à démocratiser une pratique UX jusqu’ici réservée aux applications mobiles. Grâce à son API simple et ses modèles prêts à l’emploi, les développeurs peuvent intégrer rapidement des retours haptiques adaptés à leurs besoins, et plonger leurs utilisateurs dans des interfaces plus immersives, et intuitives.

2. Les utilisateurs en colère contre Windows.

L’expansion de l’IA fait polémique, de nos jours, c’est un fait. Et vous, que diriez-vous si demain, votre système d’exploitation annonçait vouloir utiliser de l’IA pour gérer vos dossiers, vos photos et vos vidéos stockés sur votre ordinateur ?

Selon une rumeur largement relayée, Windows 12 serait sur le point de sortir avec une approche radicalement différente de ses prédécesseurs, avec un système module fortement centré sur l’intelligence artificielle, et potentiellement accessible via un abonnement. Et si l’on en croit cet article de Patrick Ruiz, cette idée est loin de plaire à tout le monde…

Même si l’article revient en réalité sur des informations incertaines, basées sur des rumeurs et des interprétations de projets internes, il démontre malgré tout l’inquiétude fondée des utilisateurs. Selon ces derniers, ces évolutions comme une véritable dérive vers un système plus intrusif, plus dépendant des services en ligne et potentiellement moins maîtrisable. C’est une approche assez polémique qui soulève une question primordiale ; à partir de quel moment notre ordinateur passera d’outil personnel à service ?

3. Pokémon Go aide aux livraisons de pizza

Pokémon Go a été un succès mondial ; à sa sortie en 2016, il a comptabilisé plus de 500 millions de téléchargements en l’espace de 2 mois. Premier grand succès de la réalité augmentée, il a fait parcourir des milliards de kilomètres à ses utilisateurs prêts à tout pour attraper leur Pokémon préféré, via la caméra de leur téléphone.

Mais cette mine de données, récoltées par ces chasseurs de Pokémons, qu’est-elle devenue, aujourd’hui ? Cet article de la MIT Technology Review nous répond ; ils ont modélisé le monde… pour livrer des pizzas.

Cette réutilisation de données pose évidemment des questions. D’un point de vue industriel, on comprend leur immense valeur. Mais d’un point de vue utilisateur, on peut se demander à quel point chacune de nos interactions numériques alimente des systèmes bien au-delà de leur usage initial ?

Pokémon Go n’était donc pas seulement un jeu en réalité augmentée ; c’était, sans le dire explicitement, une gigantesque opération de cartographie collective dont les bénéficiaires ne sont plus seulement les joueurs.

4. Les fausses idées sur le temps.

En informatique, la notion de temps, globalement universelle, n’est pas seulement une suite de secondes ou de dates ; c’est un calcul plein d’exceptions, de subtilités, et de pièges invisibles. En outre, à chaque fois que l’on peut penser maîtriser une règle simple, une situation concrète vient la remettre en question.

Le site YourCalendricalFallacyIs illustre parfaitement cela, en confrontant nos idées reçues sur le calcul du temps. À travers une série d’énoncés expliqués et corrigés, il met en évidence les nombreux cas où nos intuitions échouent face à la complexité réelle des calendriers.

Un outil pédagogique et presque ludique, qui rappelle aux développeurs que le temps n’est jamais une donnée « simple ».

5. Réaliser des maquettes en un seul clic.

Dans nos articles de veille, nous avons souvent parlé d’applications web pour créer plein de choses avec un seul clic. Aujourd’hui, dans cette même idée, nous vous présentons Stitch.

Concevoir une interface est un vrai métier, qui est très souvent composé d’allers-retours incessants entre idées, envies, et faisabilité.

Stitch, de Google, s’inscrit dans une volonté de simplifier radicalement la réalisation de maquettes. Avec l’utilisation d’un prompt classique des IA, il permet de générer des interfaces complètes à partir de croquis ou d’une simple description, tout en produisant du code exploitable. L’outil ne se limite donc pas à la création visuelle ; il relie directement l’idée au développement.

Néanmoins, si l’application semble innovante et efficace, il faut toujours s’interroger sur la place de la conception traditionnelle face à ce type d’automatisation. Car, après tout, ne vaut-il pas mieux privilégier la qualité au détriment de la vitesse ?

6. Voyez le bon côté de PHP

Le langage PHP est souvent associé à des anciennes limites et à certaines critiques historiques, au point d’être parfois perçu comme un langage dépassé, malgré sa place centrale dans le développement web. Heureusement, le site HaPHPiness est là pour nous aider à voir ses bons côtés !

Organisé par thématique, ce site met en lumière les évolutions récentes de PHP ; typage renforcé, fonctions plus cohérentes, meilleures pratiques de sécurité… Chaque point est accompagné d’exemples concrets, montrant comment ses améliorations simplifient le développement et rendent le langage plus fiable, et plus accessible.

Au-delà de son ton volontairement positif, HaPHPiness joue aussi un rôle pédagogique intéressant : il permet de prendre du recul sur l’image souvent datée de PHP et de découvrir un langage qui continue d’évoluer activement. Et c’est aussi un très bon outil pour les développeurs qui souhaitent se (re)mettre à jour, alors allez-y jeter un œil !

Pour aller plus loin…

Voici les autres liens que vous avez partagés ce mois-ci, bonne lecture !

• YGGLeak
• Why use static closures? | F2R Articles
• Anthropic’s AI tool Claude central to U.S. campaign in Iran, amid a bitter feud
• LinkedIn : ChatGPT is abandoning agentic commerce.
• SaaSpocalypse : l’effondrement des logiciels SaaS – Numerama
• SYSTÈMES AGENTIQUES REDONNER LE POUVOIR AUX MÉTIERS
• “C’est probablement fini” : Nvidia arrête les frais avec OpenAI, tout le secteur de l’IA retient son souffle – Les Numériques
• Working with stacked branches in Git is easier with –update-refs
• The Beginning Of History
• Labor market impacts of AI: A new measure and early evidence \ Anthropic
• font-optimizer pour réduire de 90% le poids de vos polices dans vos projets PHP
• Temporal: The 9-Year Journey to Fix Time in JavaScript | Bloomberg JS Blog
• Anthropic dresse un classement des métiers les plus menacés par l’IA
• image-set() – CSS | MDN
• LinkedIn : Les devs de mon équipe tapent de moins en moins de code.
• Google Just Patented The End Of Your Website
• Turn your PHP app into a standalone binary
• SaaSpocalypse Survival Scanner — Death Report
• Pretext Demos
• GitHub – chenglou/pretext: Fast, accurate & comprehensive text measurement & layout
• Anthropic : une fuite révèle les risques de la future IA « Claude Mythos » pour la cybersécurité – L’Express
• Beating every possible game of Pokemon Platinum at the same time
• Wind Waker JS

Cet article Vibrations, livraison par Pokémon Go et la complexité du temps est apparu en premier sur Synolia, agence e-commerce, CRM, Data, PIM/DAM, OMS.

Si le monde de la tech avance à toute vitesse, le cru 2026 conserve la recette qui a fait son succès. Nous étions, comme à notre habitude, présents au rendez-vous. Voici notre retour sur une édition qui prouve que Symfony reste à la pointe des évolutions.

Keynote de Fabien Potencier

Fabien Potencier nous a présenté un composant Symfony que beaucoup de gens attendaient impatiemment depuis sa première annonce datant de la SymfonyCon 2023 : Symfony TUI (pour Terminal User Interface) !

Avec l'arrivée récente et massive de l’IA dans les habitudes de travail de beaucoup de développeurs, Fabien a trouvé une raison parfaite de relancer son travail sur le composant TUI pour permettre une utilisation plus ergonomique et avancée des LLMs directement depuis un terminal.

On a d’ailleurs eu le droit à une démonstration de son propre coding agent pour voir en direct ce à quoi on pourrait s’attendre avec l'adoption de ce composant pour discuter avec des LLMs. Et le rendu rivalise avec ce qui peut aujourd’hui être proposé directement dans nos IDEs.

Mais au-delà de l’intégration évidente avec l’IA, le composant TUI, c’est aussi une évolution du composant Symfony Console que l’on utilise tous (pour rappel, il s’agit de l’un des premiers composants de l’écosystème Symfony, sorti il y a 15 ans maintenant). L’objectif ici, c’est de laisser Console s’occuper des parties commandes/arguments/output, pour concentrer toute la partie affichage, interaction et interactivité dans TUI.

Lors de ce talk assez orienté technique, Fabien a expliqué comment TUI fonctionne sous le capot. Sans entrer dans les détails ici, on pourra retenir :

• Il existe trois manières de gérer le style: à la manière stylesheet avec des sélecteurs semblables au CSS ; avec des classes utilitaires, comme on le ferait en Tailwind ; ou directement in-line, pour prendre la main de manière ponctuelle comme c'est possible en HTML. Les breakpoints sont aussi gérés avec des media-queries, pour un rendu nativement responsive ;
• Beaucoup de Widgets sont disponibles nativement pour gérer la majorité des cas d’usages (ex: TextWidget pour affichage de texte et ASCII, InputWidget pour les entrées textuelles, SelectListWidget pour des listes scrollables, etc.) mais il est évidemment possible de créer nos propres widgets pour des cas particuliers ;
• TUI utilise PHP Fibers et Revolt pour assurer un affichage et des animations complètement asynchrones et une gestion parallèle de l’affichage et de l’interactivité avec le développeur.

La liste s’allonge évidemment, et toutes les informations sont disponibles sur le Blog Post dédié à l’arrivée de Symfony TUI.

Pour conclure cette première conférence, Fabien s'est montré particulièrement enthousiaste. Ce nouveau composant Symfony ouvre des portes immenses, aussi bien pour l'affichage dans la console que pour l'intégration de l'intelligence artificielle.

Pour prouver la puissance de son outil, il a même fait une démonstration impressionnante : un jeu de Tetris tournant en direct dans son terminal ! Le rendu est fluide et visuellement bluffant, montrant que l'on peut désormais créer de véritables interfaces graphiques (TUI) modernes, directement en PHP.

Pour terminer, Fabien a lancé une idée très originale pour le futur des contributions sur ce composant : plutôt que d'envoyer une solution toute prête, les développeurs pourraient simplement partager un prompt (une instruction pour l'IA).

Fabien utiliserait alors son propre assistant et ses propres ressources pour transformer ces instructions en code réel et donner vie aux futures améliorations du projet !

La communauté au rythme de l’IA

On se souvient du SymfonyLive 2024, où l’IA générative d'images s'invitait déjà dans de nombreuses présentations. À l'époque, c’était encore une nouveauté impressionnante, bien que limitée. Cette année, le changement est radical : les agents IA étaient omniprésents dans bon nombre de sujets. Cela reflète parfaitement l'évolution de notre quotidien de développeur, qui s'accélère de plus en plus dans cette direction.

Aujourd'hui, l'IA n'est plus juste un gadget visuel, elle est au cœur du développement de Symfony :

• Les nouvelles versions de Twig (le moteur de templates de Symfony) sont désormais gérées de manière quasi automatique par un agent ;
• Une grande partie du code source est également générée par des assistants intelligents.

Cependant, un point reste essentiel : l'IA aide à produire, mais elle ne remplace pas l'humain. La responsabilité finale appartient toujours à la personne qui valide le code. C'est le développeur qui vérifie et garantit la qualité de ce qui est produit avant de l'envoyer en production.

L’IA au service des devs : Anatomie d'un assistant de Code Review - Thomas Boileau

La volonté de Thomas est de normaliser l’utilisation de l’IA au sein de sa société. Son constat est qu’il est difficile d’intervenir dans le cycle de développement logiciel, au niveau individuel, car l’usage de l’IA est encore très inégal selon les développeurs. C’est pour ça qu’il a préféré intervenir sur la CI.

Lors de sa présentation, il nous expose donc un cas pratique. Son but : construire un assistant IA qui intervient au moment des code reviews.

Techniquement, dès qu'une PR est labellisé Ready For Review (RFR) alors un webhook est lancé, et l’assistant IA est déclenché.

Ici, ce que l'on apprend n’est pas réellement comment utiliser l’IA, mais plutôt un rappel bienvenu sur l’adoption d’une fonctionnalité par des utilisateurs. Il nous a bien expliqué qu’après sa première itération, quasiment personne n'interagissait avec son agent de revue de code.

En effet, comme toutes les nouveautés, l’essentiel, c'est de construire avec les utilisateurs finaux et d’éviter au maximum la friction. C’est donc après avoir mesuré l’usage de son bot et consulté les développeurs (utilisateurs) qu’il a proposé une nouvelle version, cette fois-ci plus utile pour tout le monde.

Évidement, Thomas nous rappelle qu’il aurait pu utiliser une solution sur étagère, mais il souligne les contraintes réglementaires qui s'appliquent à son domaine.

Sa conclusion est que le plus important dans ce projet reste la DX pour avoir une bonne adoption, et surtout que ce bot IA ne remplace pas l'humain, il est créé dans le but d’être seulement un plus dans la boucle.

Développer un Coding Agent en PHP : dans les coulisses du "Harness" - Fabien Potencier

Tout a commencé par un défi sur Twitter. Un utilisateur affirmait qu'il était impossible de créer un coding agent (un assistant capable de coder de façon autonome) performant en utilisant le langage PHP. Piqué au vif, Fabien Potencier, le créateur de Symfony, a décidé de prouver le contraire en développant son propre assistant.

Plutôt que d'utiliser des outils tout prêts comme GitHub Copilot ou Claude Code, fabriquer son propre agent permet de comprendre les coulisses de l’intelligence artificielle. On découvre alors comment se déroule réellement une "discussion" entre un développeur et un modèle de langage (LLM).

Pour rendre l'outil agréable à utiliser, il a utilisé le composant TUI de Symfony. Cela permet d'avoir une interface textuelle interactive directement dans sa console.

Pour que l'agent soit intelligent, il doit communiquer avec un modèle (comme Claude Opus, Claude Sonnet, GPT 5). Mais les modèles évoluent sans cesse. Fabien a donc créé un petit outil, symfony/models-dev, qui répertorie de manière automatique tous les modèles disponibles afin de toujours utiliser la version la plus récente.

Discuter avec un chat, c'est facile. Mais pour qu'un agent soit utile, il doit pouvoir agir sur votre ordinateur. C'est là qu'interviennent les Tools (outils). De manière surprenante, Fabien n'a eu besoin que de 4 outils de base :

• Read : pour lire le contenu d'un fichier.
• Write : pour créer un nouveau fichier.
• Update : pour modifier un fichier existant sans gaspiller de token.
• Bash : pour exécuter n'importe quelle commande (lancer des tests, installer un package, etc.).

Un agent classique oublie tout dès que la session se ferme. Pour corriger cela, chaque échange est enregistré dans une base de données.

L’astuce géniale ? Cette mémoire est stockée sous forme d'arbre. Cela permet à l'agent de revenir en arrière à un point précis pour tester une autre solution si la première n'a pas fonctionné.

Plus on discute avec l'IA, plus le "contexte" (le nombre de mots envoyés) devient important. Si on dépasse la limite du modèle, il sature. Fabien a donc mis en place un système de compression intelligent :

1. Il garde toujours le tout premier message (les instructions de base).
2. Il garde les derniers messages récents.
3. Il résume tout ce qui se trouve entre les deux.

Les conseils de Fabien

Durant sa démonstration, il a partagé quelques astuces précieuses :

• Les Skills : Dès qu'il réalise qu'il répète une tâche, ou une instruction, il crée un "skill" (une compétence) pour son agent. C'est comme écrire des tests : on a l'impression de perdre du temps au début, mais on en gagne énormément sur le long terme ;
• Le regard neuf : Parfois, l'IA s'embrouille. Fabien conseille de lui demander d'analyser la situation avec "un regard neuf" (fresh eyes). Cela donne souvent des résultats spectaculaires pour débloquer un bug complexe.

Bien qu'il n'ait pas eu le temps de tout montrer, notamment son système d'orchestration dans le cloud, la preuve est faite : le PHP est un langage de choix pour l'intelligence artificielle !

Embeddings en PHP : Symfony AI en pratique - Grégoire Pineau

Le talk de Grégoire nous met tout de suite dans la pratique avec une vraie mise en situation autour des embeddings et de la similarité de contenu.

Il part sur un cas d’usage qui parle à tout le monde : faire correspondre des URLs entre un ancien et un nouveau site. Là où on pourrait partir sur des règles compliquées ou du matching approximatif, les embeddings offrent une solution plus robuste : on compare directement le sens sémantique des pages.

Ce qui marche particulièrement bien, c’est le fil rouge visuel de la conférence. Un schéma du processus est affiché, puis réutilisé à chaque étape. Ce qui rend la progression assez claire : on comprend où on en est, ce qu’on fait, et pourquoi on le fait.

La conférence prend le temps de poser les bases :

• ce qu’est un embedding (une représentation vectorielle d’un contenu) ;
• à quoi ça sert (mesurer de la similarité sémantique) ;
• et surtout dans quels cas ça devient utile.

Ensuite, on rentre dans le concret :

• comment choisir un modèle selon son besoin ;
• comment vectoriser ses données depuis Symfony ;
• où stocker ces vecteurs (PostgreSQL, Redis, etc.) ;
• et comment les requêter efficacement.

L'intérêt de cette présentation, c'est que Grégoire nous a montré que tout se fait sans quitter l’écosystème Symfony, grâce à Symfony AI. Cette initiative fournit ainsi toutes les abstractions nécessaires pour manipuler modèles, stores, agents et bien plus encore. N'hésitez pas à consulter le site dédié à Symfony AI pour découvrir tout ça. Vous pouvez retrouver ses slides en ligne.

Retours d’expériences et présentations techniques

Tous ces nouveaux outils basés sur l'IA ne doivent pas éclipser l'importance de la technicité en dehors de l'intelligence artificielle ! Au contraire, nous apprécions également les outils éprouvés et bien établis, et les retours d'expériences de manière générale.

Chiffrez vos données avec Doctrine, en restant recherchable - Jérôme Tamarelle

Lors de cette conférence, Jérôme Tamarelle a rappelé un point essentiel : la sécurité des données ne concerne pas uniquement les informations directement identifiantes (comme un email ou un nom), mais aussi les données indirectes. Croisées entre elles, ces dernières peuvent suffire à identifier une personne.

Il est important de distinguer deux approches souvent confondues :

• Le chiffrement : les données sont transformées de manière réversible. On peut les déchiffrer à l’aide d’une clé ;
• Le hashage : il s’agit d’une empreinte unique et fixe d’une donnée. Cette opération est irréversible. Plusieurs types de chiffrement existent, dont le chiffrement aléatoire et le chiffrement déterministe.

Avec le chiffrement aléatoire, chaque valeur est chiffrée différemment, même si elle est identique à une autre. Par exemple, une même adresse email enregistrée deux fois en base produira deux valeurs chiffrées différentes.

Avec le chiffrement déterministe, une même donnée produira toujours le même résultat chiffré.

Avec Doctrine, on encapsule le chiffrement directement dans Doctrine via des types personnalisés. Un champ devient "chiffré" simplement par sa définition.

Mais du coup, on ne peut plus faire de recherche sur ces champs sans passer par Doctrine.

Sécuriser ses données, c’est accepter de complexifier son application. Et surtout, le faire dès la conception.

Doctrine inheritance - Rémi JANOT

Rémi commence par présenter la différence entre héritage (mapper une hiérarchie de classe) et polymorphisme (une clef étrangère qui pointe vers une autre classe) car le vocabulaire utilisé par les différents ORM et framework peuvent parfois prêter à confusion.

S'ensuit un rappel bienvenu de l’héritage implémenté directement au niveau de Doctrine ; avec des exemples concrets, il passe en revue toutes les combinaisons possibles : soit avec des MappedSuperClass, soit des DiscriminatorMap.

Fort de son expérience, il nous explique aussi qu’il est possible d’assez facilement passer d’une architecture Single Table Inheritance (STI) vers Class Table Inheritance (CTI). Donc les choix techniques ne sont pas forcément figés, les projets évoluent, et des solutions sont toujours possibles. Il nous rappelle aussi que lorsqu’on utilise les CTI, il est important de bien vérifier les index pour gagner en performance.

JSON + SQL : hérésie ou élégance ? Retour d'expérience - Rémy Bonfils, Olivier FOURNY

On reste ici dans le thème de la modélisation de nos bases de données avec un retour d’expérience sur l’utilisation de JSON dans nos tables SQL, via l’exemple d’une application mobile offline permettant de configurer des maisons imprimées en 3D (oui oui).

Étant donné la nature très flexible des paramètres d’impression (80000 configurations possibles, importées depuis un CSV), la question de comment les stocker se pose dès le départ. Rémy et Olivier nous expliquent vouloir tout d’abord se diriger vers une modélisation de type Entity-Attribute-Valeur, où les paramètres ne sont pas représentés par des colonnes dans nos tables, mais par des lignes (ça doit parler aux personnes devant travailler sur des projets Magento ou Drupal) : beaucoup de flexibilité évidemment, mais aussi l’impossibilité d’avoir un minimum de structure dans nos données (tout est varchar). Et surtout des requêtes beaucoup plus complexes et donc des performances catastrophiques.

L’équipe se penche donc sur une autre solution : le stockage des paramètres dans des colonnes de la base de données en format JSON.

Et la surprise, les performances sont à peine inférieures à une modélisation classique de base de données (avec des tables liées par des clés étrangères), mais en gardant la flexibilité voulue ! Et grâce aux fonctions SQL permettant de manipuler du JSON, les requêtes restent simples et lisibles.

Pour notre part, à JoliCode, nous avons l’habitude de profiter du type JSON dans nos bases de données relationnelles (PostgreSQL ou MySQL), et nous vous le recommandons lorsque le besoin s’en fait ressentir.

ClickHouse pour les développeurs Symfony - Romain Neutron

Dans cette session, Romain Neutron a abordé la problématique de la gestion des données analytiques et des logs à grande échelle, des domaines où les bases relationnelles classiques comme MySQL ou PostgreSQL atteignent souvent leurs limites. Il a présenté ClickHouse, une base de données orientée colonnes ultra-performante, comme la solution idéale pour traiter des volumes massifs de données en temps réel. L'idée centrale n'est pas de remplacer votre base de données habituelle, mais de l'épauler pour des besoins spécifiques d'agrégation et de dashboards instantanés.

Côté technique, la conférence a mis en lumière la simplicité d'intégration de ClickHouse dans l'écosystème Symfony. Il a également partagé des benchmarks impressionnants comparant les temps de réponse sur des agrégations de plusieurs millions de lignes, montrant que ClickHouse peut transformer des requêtes de plusieurs secondes en résultats quasi instantanés.

Enfin, Romain a insisté sur les bonnes pratiques et les pièges à éviter, notamment sur la structure des données et le choix des moteurs de table (comme MergeTree). C'est un talk indispensable pour les développeurs cherchant à scaler leur stack analytique tout en restant dans un environnement PHP familier. De notre côté, on utilise ClickHouse dans plusieurs projets, surtout dans redirection.io pour les parties logs, analytics et crawler. On ne peut donc que vous recommander de vous y intéresser.

Ses slides sont disponibles en ligne pour retrouver toutes les informations importantes.

Symfony UX et la suite Hotwired

Cette année, on continue de parler de Symfony UX, et en particulier, deux retours d’expériences spécifiquement axés sur hotwired.dev.

Du web au mobile avec Symfony & Hotwire Native - Imad ZAIRIG

Imad nous a préparé une conférence sur le nouveau bundle Symfony UX Native qui utilise Hotwire Native. Basé sur un exemple, on peut voir comment l’application est architecturée.

On a eu l'exemple d'un bouton, rendu avec un composant bouton mobile, mais dont l'événement click est écouté par stimulus du côté de l’application Symfony

Cela fonctionne avec des webview pour que ce soit toujours Symfony qui gère le back-end et le front, mais avec des comportements mobiles gérés nativement (ex : la navigation et les transitions). On note qu’il y a quand même encore quelques fois ou il faut lancer le projet mobile avec Xcode par exemple pour iOS.

Pour utiliser les capacités natives des applications mobiles (type appareil photo) il faut passer par des "Bridges Component", ça demande malgré tout du code côté mobile.

Selon la complexité de l’application et la taille de l’équipe, Symfony UX Native est une piste à explorer.

Édition simultanée : facile avec Symfony UX - David Buchmann

Au travers d’un exemple concret David nous a fait voir comment intégrer toute la suite d’outils de hotwired.dev. Il commence avec Turbo (et un peu de Turbo Frames aussi) et nous fait voir à quel point c’est bien intégré à Symfony UX. Puis sa conférence continue avec la mise en place de Mercure (grâce à son intégration dans FrankenPHP), et finalement le tout s’intègre parfaitement via des contrôleurs Stimulus qui écoutent les messages Mercure.

Il résume les avantages de Hotwire comme ceci : la logique reste dans le backend, la sécurité est intégrée. La complexité du frontend s’en trouve réduite.

Conclusion

Si cette édition du SymfonyLive Paris 2026 nous a offert un aperçu saisissant de l'intégration massive de l'Intelligence Artificielle au cœur de l'écosystème Symfony, elle prouve une chose essentielle : l'importance des conférences n'a jamais été aussi grande. Notre métier de développeur est en pleine mutation, et nous avons fort à faire pour rester à jour.

Le fil conducteur de cette année reste cependant une évidence : quelle que soit la puissance des outils, l'humain reste au centre de la boucle. L'IA est un assistant extraordinaire pour la production de code et les tâches répétitives, mais c'est bien la communauté, la validation humaine et le partage de connaissances qui garantissent la qualité et la progression de notre écosystème. Merci aux organisateurs, aux conférenciers, et à la communauté d'avoir fait de cette édition 2026 un moment marquant, et rendez-vous l'année prochaine pour continuer à naviguer ensemble dans le futur du développement web !

Cet article Symfony Live 2026 – retours est apparu en premier sur Game And Me.