L'IA : en parler et l'intégrer

En 2026, la question sur l'IA arrive dans presque tous les entretiens. Elle teste moins votre maîtrise des outils que votre jugement : respectez-vous les règles du client, restez-vous responsable du code livré, savez-vous travailler sans assistant ? Ce chapitre prépare d'abord ce discours, puis couvre les pratiques professionnelles et l'intégration de fonctionnalités d'IA dans une app Flutter.

Partie 1 · Ce que craint un client grand compte

Avant de préparer une réponse, comprenez la question. Un responsable d'équipe dans une banque, un opérateur télécom ou une administration ne vous demande pas si vous êtes à la mode. Il évalue un risque. Ses craintes sont concrètes :

• Fuite de code et de données : du code source, des schémas d'API, des jeux de données de test ou des logs contenant des données clients envoyés à un service externe non autorisé. Pour une banque, c'est un incident de sécurité, parfois un manquement réglementaire (secret bancaire, protection des données personnelles, exigences du régulateur).
• Propriété intellectuelle : du code généré dont l'origine et la licence sont incertaines, ou du code du client réutilisé ailleurs.
• Qualité : du code qui compile mais que personne ne comprend, des tests qui ne testent rien, des failles introduites par une suggestion plausible.
• Dépendance : un consultant facturé comme senior qui ne sait plus avancer quand l'outil est indisponible ou interdit.
• Conformité : la politique de sécurité de l'entreprise, souvent stricte. Beaucoup de banques bloquent les assistants publics au niveau du proxy, autorisent seulement un outil validé (hébergé en interne ou sous contrat), ou interdisent tout.

Le discours en trois temps

Une bonne réponse tient en trois blocs, toujours dans cet ordre. Commencer par la règle rassure immédiatement ; commencer par l'usage inquiète.

Préparer deux exemples concrets

Une affirmation générale ne convainc personne. Préparez deux histoires courtes, vraies, avec un chiffre. Ne les inventez pas : un recruteur expérimenté pose deux questions de relance et une histoire fabriquée s'effondre. Canevas à remplir :

Erreurs typiques qui font de bons exemples 2 : une API Flutter dépréciée proposée avec assurance (WillPopScope, withOpacity, StateNotifier), un package inexistant ou une méthode inventée, une gestion de refresh token qui déclenche des appels concurrents, un calcul monétaire en double, un test qui vérifie le mock au lieu du comportement, une comparaison de dates sans fuseau horaire.

Ce qu'il ne faut pas dire

• « L'IA code pour moi » ou « je ne tape presque plus de code » : vous venez de dire que votre valeur est celle d'un abonnement.
• Vanter la vitesse en régie : « je vais trois fois plus vite » se traduit chez un acheteur par « le TJM devrait être divisé par trois », et chez un responsable technique par « il produit trois fois plus de code à relire ». Parlez de qualité, de tests, de délais tenus, pas de multiplicateur.
• Citer un outil interdit comme une évidence, ou expliquer comment contourner un blocage du proxy.
• Dénigrer l'IA par principe : vous passeriez pour quelqu'un qui refuse les outils de l'équipe.
• Mentionner du code client collé dans un outil grand public chez un ancien client, même pour illustrer un gain.

Réponses modèles

Version courte en anglais

Une partie de l'entretien peut se dérouler en anglais. Deux réponses à savoir dire sans lire :

Partie 2 · Un workflow assisté sain

Les entretiens techniques posent de plus en plus la question « montrez-moi comment vous travaillez avec ». La bonne réponse décrit une boucle courte où l'humain garde la main :

Fichiers d'instructions de projet. La plupart des assistants lisent un fichier de règles à la racine du dépôt (le nom dépend de l'outil ; AGENTS.md est une convention partagée par plusieurs d'entre eux). On y décrit la stack (Riverpod 3 avec Notifier, go_router, freezed), les conventions (feature-first, Result/Failure), les interdits (pas de double pour l'argent, pas de print, pas de nouvelle dépendance sans accord) et les commandes de vérification. L'équipe Flutter publie des règles officielles pour Flutter et Dart à adapter : elles poussent l'assistant vers les API actuelles et les bonnes pratiques du framework.

Revue d'une sortie d'IA. Points à vérifier systématiquement :

• Hallucinations d'API : méthode, paramètre nommé ou package qui n'existe pas. Le compilateur attrape une partie, pas les packages au nom plausible mais malveillants (typosquatting). Vérifiez chaque nouvelle dépendance sur pub.dev : éditeur vérifié, popularité, maintenance.
• Versions obsolètes : les modèles ont une date de coupure. Ils proposent souvent StateNotifier, WillPopScope, withOpacity, l'ancienne syntaxe Gradle Groovy ou des API Riverpod 2.
• Sécurité : badCertificateCallback qui renvoie true, secrets en dur, tokens dans les logs, stockage en clair dans SharedPreferences, désactivation de lints.
• Tests complaisants : assertions sur le mock, expect(true, isTrue) déguisé, tests réécrits pour passer au lieu de corriger le code.
• Sur-ingénierie : abstractions inutiles, fichiers en trop, gestion d'erreur générique qui avale les exceptions.

// Proposé avec assurance : API dépréciée, double pour l'argent, erreur avalée.
final balanceProvider = StateNotifierProvider<BalanceNotifier, double>(
  (ref) => BalanceNotifier(),
);

import 'package:flutter_riverpod/flutter_riverpod.dart';

// Riverpod 3 : AsyncNotifier, montant en centimes (int), erreurs exposées via AsyncValue.
class BalanceNotifier extends AsyncNotifier<int> {
  @override
  Future<int> build() async => ref.watch(walletRepositoryProvider).fetchBalanceMinor();
}

final balanceProvider = AsyncNotifierProvider<BalanceNotifier, int>(BalanceNotifier.new);

abstract interface class WalletRepository {
  Future<int> fetchBalanceMinor();
}

final walletRepositoryProvider = Provider<WalletRepository>(
  (ref) => throw UnimplementedError('Surchargé dans main()'),
);

Le Dart and Flutter MCP server

MCP (Model Context Protocol) est un protocole ouvert qui permet à un assistant d'appeler des outils exposés par un serveur : lire un état, lancer une commande, interroger un service. Au lieu de deviner, l'assistant consulte la réalité du projet.

Le Dart and Flutter MCP server est fourni par le SDK Dart (lancé par la commande dart mcp-server, que l'assistant configure comme serveur MCP). Il expose notamment :

• l'analyse du projet (erreurs et avertissements de l'analyzer), dart fix et dart format ;
• la résolution de symboles et la documentation via le language server ;
• l'exécution des tests et des commandes pub, la recherche sur pub.dev ;
• la connexion à une app en cours d'exécution via le Dart Tooling Daemon : hot reload, hot restart, erreurs d'exécution, logs ;
• l'inspection de l'arbre de widgets et des commandes Flutter Driver pour interagir avec l'UI.

Garder ses compétences sans IA

Beaucoup d'entretiens techniques se déroulent sans assistant : live coding en partage d'écran, exercice sur papier, revue de code orale. Le client veut voir votre raisonnement, pas celui de l'outil, et il sait que certaines de ses missions interdiront ces outils. Après des mois de travail assisté, la perte est réelle : on oublie des signatures, on hésite sur la syntaxe, on perd l'habitude de lire une stack trace jusqu'au bout.

• Désactivez l'assistant pendant les exercices chronométrés de ce site.
• Réécrivez de mémoire les briques fréquentes : AsyncNotifier, intercepteur Dio, ListView.builder paginé, test de widget avec override.
• Lisez la documentation officielle plutôt que de demander : vous retiendrez aussi le contexte.
• Expliquez votre code à voix haute : c'est exactement ce qu'on vous demandera.

Partie 3 · Intégrer de l'IA dans une app Flutter

Les clients demandent désormais des fonctionnalités d'IA : assistant de support, résumé de relevé, catégorisation de dépenses, saisie assistée. Les principes d'architecture comptent plus que le fournisseur de modèle.

Jamais de clé d'API dans le binaire

Une clé embarquée (en dur, dans --dart-define ou dans un fichier d'assets) se récupère en quelques minutes sur un APK ou une IPA. Conséquence : facture illimitée à vos frais et quota épuisé. Deux architectures acceptables :

Firebase AI Logic (nom actuel, package firebase_ai) permet d'appeler des modèles depuis l'app sans exposer de clé de modèle, à condition d'activer Firebase App Check, qui atteste que la requête provient de votre app authentique (Play Integrity sur Android, App Attest sur iOS). Pour une banque, l'option A reste la plus probable : les données transitent par un service que l'entreprise contrôle, qui peut retirer les données personnelles, appliquer des quotas et journaliser.

import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_app_check/firebase_app_check.dart';
import 'package:firebase_core/firebase_core.dart';

// Nom de modèle : consulter la documentation, les noms évoluent souvent.
const modelName = 'nom-du-modele';

Future<void> initAi() async {
  await Firebase.initializeApp();
  await FirebaseAppCheck.instance.activate(
    providerAndroid: const AndroidPlayIntegrityProvider(),
    providerApple: const AppleAppAttestProvider(),
  );
}

Stream<String> askModel(String prompt) async* {
  final model = FirebaseAI.googleAI().generativeModel(model: modelName);
  await for (final chunk in model.generateContentStream([Content.text(prompt)])) {
    final text = chunk.text;
    if (text != null) yield text;
  }
}

Cette syntaxe correspond à firebase_app_check 0.5 (octobre 2026). Les anciens paramètres androidProvider et appleProvider, encore présents dans certaines pages de documentation et dans beaucoup de sorties d'assistants, n'existent plus : bon exemple d'API qui bouge vite.

Streaming de la réponse dans l'UI

Un modèle met plusieurs secondes à produire une réponse complète. Afficher le texte au fil de l'eau réduit la latence perçue. Côté backend maison, la réponse arrive souvent en Server-Sent Events (lignes data: ...). On l'expose comme un Stream<String> derrière une interface, puis un Notifier Riverpod accumule les morceaux.

import 'dart:convert';

import 'package:dio/dio.dart';

abstract interface class AssistantApi {
  Stream<String> ask(String question);
}

class HttpAssistantApi implements AssistantApi {
  HttpAssistantApi(this._dio);
  final Dio _dio;

  @override
  Stream<String> ask(String question) async* {
    final response = await _dio.post<ResponseBody>(
      '/assistant/ask',
      data: {'question': question},
      options: Options(responseType: ResponseType.stream),
    );
    final lines = response.data!.stream
        .cast<List<int>>()
        .transform(utf8.decoder)
        .transform(const LineSplitter());
    await for (final line in lines) {
      if (line.startsWith('data: ')) yield line.substring(6);
    }
  }
}

import 'dart:async';

import 'package:flutter_riverpod/flutter_riverpod.dart';

sealed class AssistantState {
  const AssistantState();
}

final class AssistantIdle extends AssistantState {
  const AssistantIdle();
}

final class AssistantStreaming extends AssistantState {
  const AssistantStreaming(this.text);
  final String text;
}

final class AssistantDone extends AssistantState {
  const AssistantDone(this.text);
  final String text;
}

final class AssistantFailed extends AssistantState {
  const AssistantFailed(this.message, {this.partial = ''});
  final String message;
  final String partial;
}

final assistantApiProvider = Provider<AssistantApi>(
  (ref) => throw UnimplementedError('Surchargé dans main()'),
);

class AssistantController extends Notifier<AssistantState> {
  StreamSubscription<String>? _subscription;
  final _buffer = StringBuffer();

  @override
  AssistantState build() {
    ref.onDispose(() => _subscription?.cancel());
    return const AssistantIdle();
  }

  void ask(String question) {
    _subscription?.cancel(); // une seule réponse en cours à la fois
    _buffer.clear();
    state = const AssistantStreaming('');
    _subscription = ref
        .read(assistantApiProvider)
        .ask(question)
        .timeout(const Duration(seconds: 20)) // délai maximal entre deux morceaux
        .listen(
          (chunk) {
            _buffer.write(chunk);
            state = AssistantStreaming(_buffer.toString());
          },
          onError: (Object error) {
            state = AssistantFailed(
              'La réponse n\'a pas pu être obtenue. Réessayez.',
              partial: _buffer.toString(),
            );
          },
          onDone: () => state = AssistantDone(_buffer.toString()),
          cancelOnError: true,
        );
  }

  void stop() {
    _subscription?.cancel();
    _subscription = null;
    state = AssistantDone(_buffer.toString());
  }
}

final assistantControllerProvider =
    NotifierProvider<AssistantController, AssistantState>(AssistantController.new);

Dans le widget, un switch sur ref.watch(assistantControllerProvider) affiche le texte partiel, un bouton « Arrêter » pendant le streaming et un message d'erreur qui conserve la partie déjà reçue. L'interface AssistantApi se remplace par un faux dans les tests (un Stream.fromIterable de morceaux).

Coûts, erreurs, quotas, latence

• Coûts : facturation au nombre de tokens en entrée et en sortie. Limiter la taille du contexte envoyé, plafonner la longueur de réponse, mettre en cache les réponses à des questions identiques côté serveur, choisir un modèle léger pour les tâches simples (classification).
• Quotas : par utilisateur et global, appliqués côté serveur. Côté app, gérer le 429 avec un message clair et un délai, pas une boucle de retry.
• Erreurs : réseau coupé en plein streaming, réponse tronquée, contenu refusé par le filtre de sécurité, JSON invalide quand on attend une sortie structurée. Toujours valider la sortie avant de l'utiliser.
• Latence : streaming, indicateur de progression, annulation possible, et une alternative sans IA (formulaire classique) si le service est indisponible.
• Modération : filtres du fournisseur, plus des règles métier côté serveur. L'app ne doit jamais exécuter une action sensible (virement, changement de bénéficiaire) sur la seule base d'une sortie de modèle sans confirmation explicite de l'utilisateur.
• Confidentialité : informer l'utilisateur, minimiser les données envoyées (pas de numéro de compte complet, pas d'identité), vérifier les conditions de conservation et d'entraînement du fournisseur, et la localisation des données. Mettre à jour le privacy manifest iOS et la section Data safety de Google Play.

Inférence on-device

Faire tourner un petit modèle sur le téléphone supprime l'envoi de données et fonctionne hors ligne, au prix de la taille de l'app (téléchargement du modèle, souvent plusieurs centaines de Mo), de la batterie et d'une qualité moindre. Le package communautaire historique flutter_gemma a été renommé flutter_edge_ai en 2026 ; il s'appuie de préférence sur le runtime LiteRT-LM de Google (MediaPipe passant en maintenance). Le moteur et les noms de packages évoluent vite : vérifiez l'état sur pub.dev avant de le proposer à un client.

Flutter AI Toolkit, GenUI et Genkit

Flutter AI Toolkit (flutter_ai_toolkit, publié par labs.flutter.dev) fournit des widgets de chat prêts à l'emploi : LlmChatView, avec saisie texte, pièces jointes et voix. Il repose sur une interface de fournisseur abstraite ; un fournisseur Firebase AI est inclus, et l'on peut écrire le sien pour viser un backend maison.

GenUI SDK (package genui) va plus loin : au lieu de répondre par du texte, l'agent compose une interface à partir d'un catalogue de vos propres widgets (carrousel de produits, formulaire avec sélecteur de date), et les interactions de l'utilisateur lui sont renvoyées. Le format échangé suit le protocole ouvert A2UI (Agent to UI) : des messages JSON qui créent, mettent à jour ou suppriment des surfaces et des données, sans jamais envoyer de code exécutable. En Flutter 3.47, genui est en version 0.10 et s'appuie sur a2ui_core ; la documentation le présente comme expérimental (alpha) et susceptible de changer.

Genkit Dart est le portage Dart du framework Genkit : définir des flows typés (entrée, sortie, appels de modèles, outils), les tracer, les tester et les exposer en HTTP, côté serveur Dart ou dans une app. Annoncé en preview en 2026, le package genkit est passé en 1.0 sur pub.dev, avec certaines parties (agents, flux bidirectionnels) encore marquées expérimentales.

Questions d'entretien

Exercices

Quiz

12 questions. Corrigez, relisez les explications, refaites-le 48 h plus tard.

Pour aller plus loin

• Créer avec l'IA (documentation Flutter)
• Dart and Flutter MCP server
• Règles d'IA pour Flutter et Dart
• Firebase AI Logic et Firebase App Check
• firebase_ai sur pub.dev
• Flutter AI Toolkit
• GenUI SDK, genui, a2ui_core, protocole A2UI
• Genkit et genkit sur pub.dev
• flutter_edge_ai (ex flutter_gemma)
• OWASP MAS pour l'angle sécurité mobile