Le build CI passe, mais vous ne savez pas si Siri AI a réellement exécuté l’action de votre application.

La solution la plus rapide consiste à isoler le pilote, à figer Xcode 27.3 beta pour le build et les tests automatisables, puis à valider l’interaction Siri AI sur un appareil admissible. Un build réussi ne prouve ni le bon fonctionnement de l’expérience Siri AI ni l’aptitude à publier en production.

Ce guide s’adresse aux responsables de plateformes qui doivent ajouter un pilote Siri AI à une chaîne CI iOS reproductible. Il aide aussi les équipes App Intents à contrôler les actions et contenus exposés, ainsi que les responsables QA et IT chargés de distinguer expérimentation, validation sur appareil et autorisation de publication.

Dernière mise à jour : 12 novembre 2026. Informations vérifiées à partir de l’annonce Apple, des notes de version Xcode et des pages Apple sur les exigences système et l’intégration Siri AI.

Phase de cadrage : isoler le pilote avant toute modification

Au 12 novembre 2026, Apple présente Siri AI Developer Preview comme une préversion précoce, annoncée le 3 novembre 2026 pour permettre aux développeurs d’intégrer des App Intents dans les versions bêta 27.3 d’iOS, iPadOS, macOS et visionOS. Apple précise également que des conditions et règles d’utilisation supplémentaires doivent encore être communiquées. Ces limites sont indiquées dans l’annonce de la préversion destinée aux développeurs. Traitez donc ce pilote comme une vérification d’intégration, et non comme une promesse de disponibilité ou de fonctionnement en production.

Avant de toucher au pipeline existant, écrivez une courte fiche de cadrage qui précise :

  • le dépôt et la branche réservés à l’essai ;
  • les fonctionnalités App Intents incluses et celles qui restent hors périmètre ;
  • la personne responsable du pipeline, la personne qui approuve les changements d’application et la personne qui valide l’expérience ;
  • les données de test permises et les règles de conservation des journaux ;
  • les conditions d’arrêt, par exemple une incompatibilité d’outil, une consigne Apple nouvelle ou une interaction qui expose un contenu non prévu.
La séparation doit être effective, pas seulement déclarative. Utilisez un workflow distinct, des réglages de build explicitement sélectionnés et un emplacement d’artefacts qui ne puisse pas remplacer ceux du processus stable. Si votre système de CI partage des variables, des secrets de signature ou des tâches de publication avec la chaîne courante, documentez lesquels sont nécessaires au pilote et désactivez les étapes de publication qui n’y ont pas leur place.

La sortie attendue de cette phase est une base de comparaison : révision du code, configuration du workflow, version Xcode sélectionnée, SDK cible, résultats du build et tests déjà exécutés. Sans cette référence, un échec ultérieur peut provenir d’un changement de code, d’un outil bêta ou d’une modification du pipeline, et le diagnostic devient ambigu.

Comment isoler Siri AI Developer Preview de la chaîne officielle ?

Ne faites pas évoluer le workflow de publication stable pour y introduire une dépendance à Siri AI Developer Preview. Créez plutôt un trajet d’essai autonome, avec ses propres déclencheurs et sa propre règle d’approbation. La chaîne régulière doit continuer à sélectionner son Xcode approuvé, même si le pilote adopte temporairement une version bêta.

Prévoyez aussi un retour arrière simple : supprimer ou désactiver le workflow expérimental ne doit pas modifier les paramètres de signature, les tâches de distribution ni les artefacts attendus par les équipes de publication. Cette séparation permet de suspendre l’essai sans transformer l’arrêt du pilote en incident de livraison.

Phase d’environnement : fixer Xcode et rendre le build vérifiable

Le choix de Xcode 27.3 beta doit être explicite dans le job de CI ; ne laissez pas le runner sélectionner par défaut la version disponible. Apple a publié les notes de version de Xcode 27.3 beta, qui décrivent les changements connus et les exigences propres à cette version. Consultez également la page Apple des exigences système de Xcode avant de réserver ou de préparer le nœud de build.

Les exigences peuvent évoluer entre versions bêta. Ne déduisez donc pas la compatibilité d’un runner de son ancienneté ou du fait qu’il compilait déjà le projet avec une autre version de Xcode. Vérifiez les exigences en vigueur au moment de chaque mise à jour, puis consignez dans le journal du job le Xcode effectivement lancé, le SDK sélectionné, la cible de compilation et l’état du dépôt.

<
Point de contrôleWorkflow stablePilote Siri AI isoléPreuve à conserver
Sélection de XcodeVersion approuvée pour les livraisons courantesXcode 27.3 beta choisi explicitementVersion réellement lancée dans le job
Réglages et SDKRéférence actuelle du projetConfiguration expérimentale documentéeParamètres de build et cible utilisés
TestsTests déjà admis dans la chaîne couranteTests automatisables pertinents pour le piloteRésultats associés à la révision compilée
PublicationÉtapes définies par le processus de livraisonPublication désactivée sauf autorisation distincteÉtat des étapes et emplacement de l’artefact
Cette comparaison sert à établir les responsabilités, pas à déclarer qu’une chaîne est « meilleure ». Dans le pilote, enregistrez aussi le résultat d’un build de référence avant d’ajouter les changements App Intents. Vous pourrez ensuite distinguer une régression introduite par le code d’une différence liée au nouvel environnement.

Comment utiliser Xcode 27.3 beta pour un pilote d’entreprise ?

Définissez une image ou un runner réservé au pilote, puis installez ou sélectionnez la version attendue conformément aux notes de version Apple. La procédure doit échouer clairement si le job ne trouve pas cette version : poursuivre silencieusement avec un autre Xcode produirait des résultats difficiles à reproduire.

Ajoutez au rapport du job les informations nécessaires au diagnostic sans y verser de secrets. Vérifiez que les journaux indiquent le Xcode utilisé et les réglages pertinents, puis rattachez le résultat du build à la révision exacte du dépôt. Si le runner est administré par une équipe plateforme, demandez à cette équipe de contrôler les mises à jour automatiques, la disponibilité de l’espace de travail et les droits d’accès aux artefacts. Ce sont des contrôles d’exploitation internes, et non des garanties fournies par le statut bêta de l’outil.

Le pilote peut réutiliser des tests déjà automatisés si leur exécution est compatible avec l’environnement. En revanche, un test vert ne prouve que ce qu’il vérifie effectivement : il ne confirme pas à lui seul la découverte d’une action par Siri AI ni le déroulement de l’expérience dans des conditions d’usage réelles.

Phase de code : intégrer les App Intents dans le périmètre défini

Commencez par inventorier les App Intents prévus pour le pilote : actions déclarées, entités ou contenus associés, paramètres attendus et effets possibles. L’objectif est de permettre une revue précise de ce que l’application rend accessible, pas d’ajouter des intentions hypothétiques afin de « couvrir » Siri AI.

Appuyez-vous sur le guide Apple de démarrage avec le framework App Intents pour organiser l’intégration, puis confrontez les choix du projet aux instructions Apple sur Apple Intelligence et Siri AI. Apple documente également les principes de découverte des actions et des contenus. Ces références évoluant avec la préversion, vérifiez-les à nouveau lorsque vous mettez à jour Xcode ou le système de test.

Pour chaque action incluse, la revue de code devrait répondre à des questions concrètes :

  • L’action est-elle compréhensible et correctement décrite pour l’usage visé ?
  • Les paramètres acceptés sont-ils limités aux valeurs attendues ?
  • Le résultat renvoyé à l’utilisateur ne révèle-t-il pas de contenu qui devrait rester privé ?
  • Les erreurs, l’absence de données ou les droits insuffisants produisent-ils un résultat maîtrisé ?
  • Les opérations modifiant des données peuvent-elles être identifiées et validées avant d’être exécutées ?
Si l’application propose des fonctions créatives — par exemple sélectionner un projet de montage, retrouver une ressource audio ou lancer une action de design — vérifiez que le modèle d’action correspond au travail réel de l’utilisateur. Une description technique qui compile peut rester trop vague pour guider une interaction utile ; à l’inverse, une action trop large peut donner accès à des opérations que l’équipe n’a pas souhaité exposer.

À ce stade, séparez trois constats dans la revue : le code est accepté par le compilateur ; l’action respecte les règles de conception et de sécurité du projet ; l’interaction est effectivement reconnue et utilisable dans l’environnement admissible. Le premier constat est vérifiable dans CI. Les suivants nécessitent des contrôles supplémentaires et ne doivent pas être déduits de la seule compilation.

Phase de CI : construire, tester et relier chaque résultat à son artefact

Exécutez le build et les tests automatisables dans le workflow isolé. Veillez à ce que les journaux permettent de retrouver la révision, la sélection de Xcode, le SDK cible et les résultats des tests. Conservez les artefacts selon les règles internes du projet, en évitant d’intégrer par erreur une sortie expérimentale au circuit de publication stable.

Un rapport utile ne se limite pas à afficher « réussi » ou « échoué ». Il doit aider l’équipe à répondre à ces questions : quel code a été compilé, dans quel environnement, avec quels réglages, et quels tests ont réellement été exécutés ? Si le build réussit mais qu’un test ne s’exécute pas, consignez cette distinction au lieu de présenter l’ensemble du job comme une validation complète.

Classez les preuves sous des catégories distinctes :

  • Vérification du code : revue des actions exposées, des paramètres et des résultats.
  • Build : compilation avec la version Xcode et le SDK consignés.
  • Tests automatisés : contrôles effectivement exécutés et associés à la révision.
  • Expérience sur appareil : observation d’une interaction Siri AI dans un contexte répondant aux critères Apple.
  • Décision de publication : autorisation séparée, fondée sur les exigences de votre organisation et les informations Apple alors disponibles.
Apple explique comment [construire et exécuter une application sur simulateur ou appareil](https://developer.apple.com/documentation/xcode/building-and-running-an-app?changes=_9&language=objc). Un simulateur peut contribuer aux contrôles d’application pertinents, mais ne remplace pas la vérification d’une expérience Siri AI réelle lorsque celle-ci dépend de critères d’admissibilité ou d’une interaction sur appareil.

Ne transformez pas la réussite d’un job en validation implicite de la fonctionnalité. Faites apparaître dans le rapport le périmètre réellement couvert, les tests absents et les contrôles qui restent à effectuer sur appareil.

En cas d’échec, comparez d’abord la configuration du job à la référence du pilote : version Xcode, sélection du SDK, révision du code et tests lancés. Ensuite seulement, attribuez l’incident au code ou à la préversion. Cette discipline évite de modifier en même temps le pipeline, les App Intents et les réglages du runner, ce qui rendrait l’origine du changement difficile à établir.

Phase d’acceptation : vérifier l’interaction sur un appareil admissible

Avant de planifier les essais, contrôlez les critères Apple en vigueur pour l’appareil, la version du système, la langue, la région et la disponibilité de Siri AI. Ne déduisez pas ces critères du fait que l’application se compile ou que le système bêta est installé. L’annonce Apple et la documentation d’intégration constituent les références à consulter, et leurs conditions peuvent changer au fil de la préversion.

Préparez un scénario d’acceptation par action : état initial de l’application, formulation ou geste utilisé, action attendue, résultat observé et limites rencontrées. Gardez le scénario suffisamment précis pour qu’un autre membre de l’équipe puisse le rejouer. Si l’action touche des données de compte ou un contenu de travail, réalisez le test avec un compte et des ressources appropriés, plutôt qu’avec des données réelles non nécessaires.

CI réussi : faut-il encore tester Siri AI sur appareil ?

Oui, si vous devez savoir si l’interaction Siri AI fonctionne réellement dans un environnement admissible. Le CI peut établir que le code compile et que les tests exécutés réussissent ; il ne démontre pas à lui seul que Siri AI découvre l’action, interprète correctement la demande ou présente le résultat attendu. Une validation sur appareil complète donc les preuves de pipeline, elle ne les remplace pas.

Consignez les observations de manière factuelle : action demandée, réponse de l’application, éventuelle ambiguïté, refus ou limitation, puis version du système et conditions pertinentes du test. Distinguez ce que vous avez vu de ce que vous supposez. Si le test échoue, déterminez s’il s’agit d’un défaut de l’action, d’une limite de la préversion ou d’un critère d’admissibilité non satisfait avant de changer le code.

Pour rendre la décision lisible en revue, attribuez à chaque preuve un état qualitatif :

  • Non vérifié : aucune preuve conservée pour ce contrôle.
  • Partiellement vérifié : une preuve existe, mais elle ne couvre pas le scénario ou les conditions visés.
  • Démontré dans le périmètre du pilote : le contrôle a été effectué, son résultat est traçable et ses limites sont notées.
Cette grille ne constitue ni un indicateur de qualité Apple ni une certification. Elle empêche simplement de confondre un contrôle de compilation avec une validation de l’usage.

Phase de décision : élargir, suspendre ou revenir au processus stable

À la fin du pilote, réunissez les journaux de build, les résultats des tests automatisés, les observations sur appareil, la revue des actions exposées et les points encore incertains dans la documentation ou les règles de préversion. Décidez alors si vous poursuivez l’expérimentation, si vous attendez une clarification ou si vous désactivez le workflow. Chaque option doit laisser la chaîne de publication stable dans l’état prévu.

Utilisez cette liste de contrôle avant la revue de décision :

  • [ ] Le workflow du pilote est séparé du workflow de livraison stable.
  • [ ] Le job sélectionne explicitement Xcode 27.3 beta et conserve une preuve de la version réellement exécutée.
  • [ ] Le SDK cible et la révision du code sont associés aux résultats du build.
  • [ ] Les tests automatisables exécutés sont identifiés, et les tests non exécutés ne sont pas présentés comme réussis.
  • [ ] Les App Intents inclus dans le pilote ont fait l’objet d’une revue portant sur leur usage, leurs paramètres et leurs résultats.
  • [ ] Les critères Apple relatifs à l’appareil, à la langue, à la région et à la version du système ont été revérifiés.
  • [ ] Une interaction réelle a été testée sur un appareil admissible lorsque l’objectif du pilote l’exige.
  • [ ] Les limites observées et les points de politique encore incertains sont documentés.
  • [ ] La décision d’élargir ou de suspendre le pilote n’active pas automatiquement une publication de production.
Pour noter le dossier, ne comptez pas les cases cochées comme si elles avaient toutes la même portée. Une compilation traçable ne compense pas l’absence d’essai sur appareil si l’objectif est de valider l’expérience Siri AI ; de même, une interaction convaincante sur un appareil ne prouve pas la reproductibilité du workflow. La décision doit refléter les preuves manquantes et le niveau de risque accepté par votre organisation.

Enfin, n’autorisez pas le passage en production sur la seule base du pilote. Réévaluez-le après publication d’une version appropriée, clarification des conditions applicables et exécution des contrôles de retour en régression définis par votre équipe. Tant que ces éléments ne sont pas réunis, maintenez la séparation entre le workflow bêta et le processus de livraison officiel.

Si votre environnement actuel ne permet pas de réserver un runner au pilote, commencez par vérifier si un Mac distant peut répondre à vos exigences d’isolement, d’accès, d’outillage et de conservation des artefacts. Les pages des environnements Mac proposés par MACGPU et de présentation de MACGPU peuvent servir de point de départ pour examiner les conditions de mise à disposition, sans présumer qu’elles correspondent à votre politique interne. Pour une expérimentation temporaire, la location peut éviter de modifier le parc de postes ; si vous avez besoin d’une capacité dédiée en permanence ou d’interfaces physiques particulières, comparez-la plutôt à un Mac détenu et administré par votre équipe. Vérifiez les conditions réelles avant d’engager le pilote, et ne faites pas dépendre la chaîne de production d’un environnement qui n’a pas encore passé vos propres contrôles d’acceptation.