Claude Code - Questions d'entretien

Préparer un entretien technique sur Claude Code exige de maîtriser les commandes CLI, le système de mémoire, les permissions et l'intégration MCP. Ce guide rassemble 27 questions d'entretien classées par niveau - junior, mid-level et senior - avec des réponses modèles, les points-clés à mentionner et les pièges à éviter pour réussir votre interview sur le coding agentique.

Claude Code est l'agent de développement en ligne de commande d'Anthropic qui permet aux développeurs d'interagir avec Claude directement depuis leur terminal pour générer, refactorer et déboguer du code. cet outil s'impose comme une référence dans le domaine du coding agentique et fait l'objet de questions d'entretien de plus en plus fréquentes.

Claude Code traite en moyenne 87 % des tâches de développement courantes sans quitter le terminal. Les recruteurs testent désormais la capacité des candidats à exploiter ces outils d'IA pour accélérer leur productivité.

Comment se structurent les questions d'entretien Claude Code par niveau ?

Les entretiens techniques évaluent trois paliers de compétence sur Claude Code. Le niveau junior vérifie les bases CLI et l'installation. Le niveau mid-level couvre la configuration avancée, les permissions et la mémoire. Le niveau senior explore l'architecture MCP, l'automatisation et les stratégies d'intégration en équipe.

Pour bien démarrer votre préparation, consultez le guide sur l'installation et le premier lancement qui couvre les prérequis techniques fondamentaux.

À retenir : structurez votre préparation par niveau de difficulté et concentrez-vous d'abord sur les fondamentaux avant d'aborder les sujets avancés.

Quelles questions d'entretien Claude Code posent les recruteurs au niveau junior ?

Question 1 : Qu'est-ce que Claude Code et en quoi diffère-t-il de l'interface web de Claude ?

Réponse modèle : Claude Code est un agent CLI qui s'exécute directement dans le terminal. Contrairement à l'interface web, il accède au système de fichiers local, exécute des commandes shell et interagit avec Git nativement. Il fonctionne avec le modèle Claude Sonnet 4.6 par défaut en février 2026.

Points-clés à mentionner :

• Accès direct au file system
• Exécution de commandes bash
• Intégration Git native
• Consommation de tokens via l'API Anthropic

Piège courant : ne pas confondre Claude Code avec un simple chatbot - c'est un agent autonome capable de modifier des fichiers.

Question 2 : Comment installer Claude Code sur votre machine ?

Réponse modèle : Exécutez la commande suivante pour installer Claude Code globalement :

npm install -g @anthropic-ai/claude-code

Node.js 22 ou supérieur est requis. Après installation, lancez claude dans votre terminal pour démarrer une session.

Points-clés à mentionner :

• Prérequis : Node.js ≥ 22
• Installation globale via npm
• Clé API Anthropic nécessaire
• Authentification au premier lancement

Piège courant : oublier de configurer la variable d'environnement ANTHROPIC_API_KEY avant le premier lancement. Consultez le guide complet sur vos premières conversations pour éviter cette erreur.

Question 3 : Quelles sont les trois commandes slash indispensables dans Claude Code ?

Réponse modèle : Les trois commandes essentielles sont /help pour afficher l'aide, /clear pour réinitialiser le contexte et /compact pour compresser la conversation. En pratique, /compact réduit la consommation de tokens de 40 à 60 % sur les longues sessions.

# Dans une session Claude Code
/help       # Affiche les commandes disponibles
/clear      # Réinitialise le contexte
/compact    # Compresse la conversation

Points-clés à mentionner :

• /help - documentation intégrée
• /clear - reset du contexte
• /compact - optimisation mémoire
• D'autres commandes existent : /init, /config

Piège courant : utiliser /clear au lieu de /compact quand vous voulez conserver un résumé du contexte. Approfondissez avec le guide des commandes slash essentielles.

Question 4 : Comment formuler un prompt efficace pour Claude Code ?

Réponse modèle : Structurez votre prompt en trois parties : le contexte (quel fichier ou projet), l'action attendue (refactorer, corriger, créer) et les contraintes (langage, conventions). Un prompt précis réduit le nombre de tours d'échange de 70 % selon les benchmarks Anthropic.

Points-clés à mentionner :

• Spécifier les fichiers concernés
• Décrire le résultat attendu
• Indiquer les contraintes techniques
• Utiliser le format impératif

Piège courant : rédiger des prompts vagues comme "améliore le code" sans contexte.

Question 5 : Que se passe-t-il quand Claude Code atteint la limite de contexte ?

Réponse modèle : Quand la fenêtre de contexte approche sa limite (200 000 tokens pour Claude Sonnet 4.6), Claude Code compresse automatiquement les messages précédents. Le système conserve un résumé des échanges et les informations critiques.

Points-clés à mentionner :

• Limite de 200 000 tokens
• Compression automatique
• Conservation des résumés
• Possibilité de forcer avec /compact

Piège courant : penser que la compression supprime toutes les informations précédentes.

Question 6 : Comment Claude Code gère-t-il les fichiers de votre projet ?

Réponse modèle : Claude Code utilise des outils dédiés pour lire (Read), écrire (Write) et éditer (Edit) les fichiers. Il préfère l'édition de fichiers existants à la création de nouveaux fichiers. Chaque modification passe par le système de permissions avant exécution.

Points-clés à mentionner :

• Outils Read, Write, Edit, Glob, Grep
• Préférence pour l'édition sur la création
• Système de permissions actif
• Accès au file system local uniquement

Piège courant : croire que Claude Code peut accéder à des fichiers distants ou à des URLs arbitraires.

Question 7 : Quelle est la différence entre le mode plan et le mode implémentation ?

Réponse modèle : Le mode plan permet à Claude Code d'explorer le codebase et de proposer une stratégie avant d'écrire du code. Concrètement, il lit et analyse les fichiers sans les modifier. Le mode implémentation autorise les modifications effectives. En pratique, 65 % des projets complexes bénéficient d'une phase de planification préalable.

Points-clés à mentionner :

• Mode plan : lecture seule, pas de modifications
• Mode implémentation : édition autorisée
• Validation utilisateur entre les deux phases
• Réduction des erreurs grâce à la planification

Piège courant : sauter l'étape de planification sur des tâches multi-fichiers.

Question 8 : Comment arrêter une opération en cours dans Claude Code ?

Réponse modèle : Appuyez sur Escape pour interrompre la génération en cours. Pour annuler une commande bash lancée par Claude Code, utilisez Ctrl+C. Ces raccourcis fonctionnent dans tous les modes de permission.

Points-clés à mentionner :

• Escape - stopper la génération
• Ctrl+C - interrompre une commande bash
• Aucune perte de contexte après interruption
• La session reste active

Piège courant : fermer le terminal au lieu d'utiliser les raccourcis, ce qui perd tout le contexte de session.

Question 9 : Comment vérifier que Claude Code fonctionne correctement après installation ?

Réponse modèle : Lancez claude --version pour vérifier la version installée, puis exécutez claude dans un projet Git pour valider l'accès au file system. Un test rapide consiste à demander "liste les fichiers du projet" pour confirmer les permissions de lecture.

claude --version    # Vérifie la version
claude              # Lance une session interactive

Points-clés à mentionner :

• Vérification de version
• Test dans un répertoire Git
• Validation des permissions de lecture
• Vérification de la clé API

Piège courant : tester Claude Code hors d'un répertoire Git, ce qui limite ses capacités d'analyse contextuelle.

À retenir : les questions junior vérifient votre compréhension des fondamentaux - installation, commandes de base et interaction avec le terminal.

Quelles questions d'entretien Claude Code ciblent le niveau mid-level ?

Question 10 : Comment fonctionne le système de mémoire CLAUDE.md ?

Réponse modèle : Le fichier CLAUDE.md est le système de mémoire persistante de Claude Code. Il stocke les conventions de projet, les préférences de l'utilisateur et les instructions récurrentes. Claude Code charge automatiquement ce fichier au démarrage de chaque session. La commande /init génère un CLAUDE.md initial basé sur l'analyse du projet.

# Initialiser le fichier CLAUDE.md
/init

# Contenu typique d'un CLAUDE.md
# - Conventions de nommage
# - Stack technique du projet
# - Règles de linting
# - Patterns architecturaux

Points-clés à mentionner :

• Trois niveaux : projet (.claude/CLAUDE.md), utilisateur (~/.claude/CLAUDE.md), répertoire courant
• Chargement automatique au lancement
• Format Markdown libre
• Commande /init pour la génération

Pour maîtriser ce sujet, explorez le guide sur le système de mémoire CLAUDE.md qui détaille chaque niveau de configuration.

Piège courant : ne pas structurer le CLAUDE.md, ce qui dilue les instructions dans un fichier trop long.

Question 11 : Comment configurer les permissions de Claude Code pour un projet d'équipe ?

Réponse modèle : Configurez les permissions via le fichier .claude/settings.json à la racine du projet. Trois modes existent : default (confirmation pour chaque action), acceptEdits (éditions auto-approuvées) et bypassPermissions (aucune confirmation). En contexte d'équipe, le mode default avec des exceptions ciblées offre le meilleur équilibre sécurité/productivité.

{
  "permissions": {
    "allow": ["Read", "Glob", "Grep"],
    "deny": ["Bash(rm *)"]
  }
}

Points-clés à mentionner :

• Fichier .claude/settings.json versionné avec le projet
• Trois modes de permission
• Listes allow/deny granulaires
• Distinction entre outils (Read, Write, Bash)

Consultez la checklist de sécurité des permissions pour un déploiement sécurisé en équipe.

Piège courant : utiliser bypassPermissions en production - ce mode désactive toute confirmation y compris pour les commandes destructrices.

Question 12 : Comment Claude Code interagit-il avec Git ?

Réponse modèle : Claude Code détecte automatiquement les dépôts Git et utilise les commandes Git nativement. Il peut créer des commits, des branches, analyser les diffs et même créer des pull requests via gh. En pratique, Claude Code suit un protocole de sécurité Git strict : il ne force jamais un push et ne modifie jamais la configuration Git.

Points-clés à mentionner :

• Détection automatique du dépôt Git
• Commits avec co-auteur Co-Authored-By: Claude
• Protocole de sécurité : jamais de --force non autorisé
• Intégration gh pour les PR

Piège courant : s'attendre à ce que Claude Code push automatiquement - il demande toujours confirmation.

Question 13 : Quelle est la différence entre /compact et /clear ?

Réponse modèle : /compact compresse le contexte en conservant un résumé structuré des échanges précédents. La conversation continue avec ce résumé. /clear supprime intégralement le contexte et redémarre une session vierge. Concrètement, /compact réduit le nombre de tokens de 50 à 70 % tout en préservant les décisions prises.

Points-clés à mentionner :

• /compact préserve un résumé
• /clear repart de zéro
• /compact accepte un argument optionnel pour cibler le résumé
• Impact direct sur les coûts API

Piège courant : utiliser /clear par réflexe alors que /compact suffirait, perdant ainsi le contexte utile.

Question 14 : Comment utiliser Claude Code en mode non-interactif (headless) ?

Réponse modèle : Utilisez le flag -p (ou --print) pour exécuter Claude Code en mode non-interactif. Ce mode est essentiel pour l'intégration dans les pipelines CI/CD. La sortie est directement écrite sur stdout sans interface interactive.

# Mode non-interactif
claude -p "Analyse ce fichier et liste les bugs potentiels" src/app.ts

# Avec format de sortie JSON
claude -p "Liste les TODO" --output-format json

# Dans un pipeline
echo "Génère les tests unitaires" | claude -p

Points-clés à mentionner :

• Flag -p ou --print
• Sortie directe sur stdout
• Compatible CI/CD (GitHub Actions, GitLab CI)
• Option --output-format pour JSON

Piège courant : oublier que le mode headless ne demande aucune confirmation - les permissions doivent être pré-configurées.

Question 15 : Comment optimiser la consommation de tokens dans Claude Code ?

Réponse modèle : Trois stratégies réduisent la consommation. D'abord, utilisez /compact régulièrement pour compresser le contexte. Ensuite, rédigez des prompts précis qui ciblent des fichiers spécifiques. Enfin, configurez CLAUDE.md avec les instructions récurrentes pour éviter de les répéter. En pratique, ces techniques réduisent les coûts API de 30 à 50 % sur un mois.

Points-clés à mentionner :

• Compression régulière avec /compact
• Prompts ciblés (fichiers, lignes)
• CLAUDE.md pour les instructions persistantes
• Monitoring via le dashboard Anthropic

Piège courant : ne pas surveiller sa consommation et découvrir une facture élevée en fin de mois.

Question 16 : Comment Claude Code gère-t-il les erreurs de commandes bash ?

Réponse modèle : Quand une commande bash échoue, Claude Code analyse le code de retour et le message d'erreur. Il propose ensuite une correction ou une approche alternative. Il n'essaie jamais de forcer la même commande en boucle. Voici comment gérer les erreurs fréquentes :

1. Vérifier le message d'erreur affiché
2. Analyser le code de retour (exit code)
3. Proposer une commande corrigée
4. Demander confirmation avant réexécution

Points-clés à mentionner :

• Analyse automatique des erreurs
• Pas de retry en boucle
• Proposition d'alternatives
• Escalade vers l'utilisateur si nécessaire

Piège courant : penser que Claude Code va résoudre automatiquement toutes les erreurs sans intervention.

Question 17 : Comment utiliser les hooks dans Claude Code ?

Réponse modèle : Les hooks sont des commandes shell déclenchées par des événements Claude Code (avant/après un tool call, à la soumission d'un prompt). Configurez-les dans le fichier .claude/settings.json. En pratique, 45 % des équipes utilisent les hooks pour lancer un linter automatiquement après chaque édition de fichier.

{
  "hooks": {
    "post-edit": "npx eslint --fix ${file}"
  }
}

Points-clés à mentionner :

• Événements : pre-tool, post-tool, prompt-submit
• Configuration dans settings.json
• Variables disponibles (fichier, commande)
• Feedback traité comme venant de l'utilisateur

Piège courant : créer des hooks qui bloquent l'exécution sans message d'erreur clair.

Question 18 : Comment Claude Code sélectionne-t-il le modèle à utiliser ?

Réponse modèle : Par défaut, Claude Code utilise Claude Sonnet 4.6 comme modèle principal en février 2026. Le modèle peut être changé via la configuration ou les flags CLI. Les agents enfants (subagents) peuvent utiliser des modèles différents selon la tâche - par exemple, Haiku 4.5 pour les recherches rapides.

Points-clés à mentionner :

• Modèle par défaut : Sonnet 4.6
• Configuration possible par projet
• Subagents avec modèles dédiés
• Impact direct sur les coûts et la latence

Piège courant : utiliser systématiquement Opus pour toutes les tâches, ce qui multiplie les coûts par 5 sans gain proportionnel.

À retenir : le niveau mid-level évalue votre capacité à configurer Claude Code pour un usage professionnel - mémoire, permissions, optimisation et intégration Git.

Quelles questions d'entretien Claude Code réservent aux profils seniors ?

Question 19 : Comment intégrer Claude Code dans un pipeline CI/CD ?

Réponse modèle : Configurez Claude Code en mode headless (-p) dans vos GitHub Actions ou GitLab CI. Voici un workflow type pour la revue de code automatisée :

# .github/workflows/claude-review.yml
name: Claude Code Review
on: pull_request
jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm install -g @anthropic-ai/claude-code
      - run: |
          claude -p "Analyse ce diff et identifie les problèmes" \
            --output-format json > review.json
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

Points-clés à mentionner :

• Mode headless avec -p
• Gestion sécurisée des secrets
• Format de sortie JSON pour le parsing
• Permissions pré-configurées (pas d'interaction)
• Timeout à configurer (120 secondes par défaut)

Pour comprendre les enjeux de sécurité en CI/CD, référez-vous au guide sur les permissions et la sécurité.

Piège courant : stocker la clé API en clair dans le fichier de configuration au lieu d'utiliser les secrets du CI.

Question 20 : Qu'est-ce que le Model Context Protocol (MCP) et comment l'utiliser avec Claude Code ?

Réponse modèle : Le Model Context Protocol (MCP) est un standard ouvert qui permet à Claude Code de se connecter à des sources de données et des outils externes via des serveurs dédiés. Chaque serveur MCP expose des "tools" que Claude Code peut invoquer. MCP réduit de 80 % le temps d'intégration avec des systèmes tiers.

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"]
    }
  }
}

Points-clés à mentionner :

• Standard ouvert d'Anthropic
• Architecture client-serveur
• Serveurs communautaires disponibles (Postgres, GitHub, Slack)
• Configuration dans .claude/settings.json

Consultez la checklist MCP pour une mise en œuvre sécurisée.

Piège courant : exposer un serveur MCP sans restrictions d'accès - chaque serveur doit avoir des permissions minimales.

Question 21 : Comment architecturer la mémoire Claude Code pour une équipe de 10+ développeurs ?

Réponse modèle : Structurez la mémoire sur trois niveaux. Le CLAUDE.md du projet (versionné) contient les conventions partagées. Le CLAUDE.md utilisateur (~/.claude/CLAUDE.md) stocke les préférences individuelles. Le fichier .claude/settings.json du projet définit les permissions d'équipe.

Projet/
├── CLAUDE.md               # Conventions d'équipe (versionné)
├── .claude/
│   ├── settings.json        # Permissions partagées
│   └── CLAUDE.md            # Instructions de dépôt
└── src/
    └── CLAUDE.md            # Instructions spécifiques au dossier

Points-clés à mentionner :

• CLAUDE.md versionné = source de vérité partagée
• Préférences individuelles dans le home directory
• Hiérarchie : projet > répertoire > utilisateur
• Revue des CLAUDE.md en code review

Piège courant : laisser chaque développeur définir ses propres conventions sans fichier partagé, ce qui crée des incohérences.

Question 22 : Comment évaluer la qualité du code généré par Claude Code ?

Réponse modèle : Mettez en place quatre garde-fous. Premièrement, les hooks post-édition lancent les linters automatiquement. Deuxièmement, les tests unitaires sont exécutés après chaque génération. Troisièmement, le CLAUDE.md encode les standards qualité. Quatrièmement, la revue humaine reste obligatoire pour les merges.

Points-clés à mentionner :

• Hooks post-édition pour le linting
• Exécution automatique des tests
• Standards encodés dans CLAUDE.md
• Revue humaine irremplaçable

Pour approfondir les bonnes pratiques de prompt et de revue, consultez les astuces pour vos premières conversations.

Piège courant : faire confiance aveuglément au code généré sans tests ni revue.

Question 23 : Comment utiliser les subagents (Task tool) efficacement ?

Réponse modèle : Les subagents permettent de paralléliser les tâches et d'isoler les contextes. Lancez un agent Explore pour la recherche de code, un agent Bash pour les opérations système et un agent general-purpose pour les tâches complexes. En pratique, l'utilisation de subagents parallèles réduit le temps de complétion de 40 à 60 % sur les projets multi-fichiers.

Points-clés à mentionner :

• Types : Explore, Bash, general-purpose, Plan
• Exécution parallèle pour les tâches indépendantes
• Isolation du contexte principal
• Communication par retour de résultat

Piège courant : lancer des subagents en série quand les tâches sont indépendantes - la parallélisation est le principal avantage.

Question 24 : Comment sécuriser Claude Code dans un environnement d'entreprise ?

Réponse modèle : Appliquez le principe du moindre privilège à trois niveaux. Restreignez les commandes bash autorisées via les permissions deny-list. Limitez l'accès au file system aux répertoires du projet. Contrôlez les serveurs MCP autorisés. En 2026, les entreprises conformes SOC 2 exigent ces trois contrôles minimum.

{
  "permissions": {
    "deny": [
      "Bash(curl *)",
      "Bash(wget *)",
      "Bash(rm -rf *)",
      "Write(~/.ssh/*)"
    ]
  }
}

Points-clés à mentionner :

• Deny-list pour commandes dangereuses
• Isolation au répertoire projet
• Audit des serveurs MCP
• Rotation des clés API
• Logs d'activité

Piège courant : autoriser Bash(*) pour "gagner du temps" - c'est un vecteur d'attaque direct.

Question 25 : Comment Claude Code gère-t-il les projets monorepo ?

Réponse modèle : Claude Code navigue dans les monorepos en utilisant les outils Glob et Grep pour localiser les fichiers pertinents. Configurez un CLAUDE.md racine décrivant la structure du monorepo et des CLAUDE.md spécifiques dans chaque package. Concrètement, un monorepo de 500 000 lignes de code se parcourt en moins de 3 secondes grâce aux outils de recherche optimisés.

Points-clés à mentionner :

• CLAUDE.md hiérarchiques (racine + packages)
• Outils Glob/Grep performants sur de gros volumes
• Contexte limité : cibler les fichiers pertinents
• Configuration par sous-projet possible

Piège courant : ne pas structurer le CLAUDE.md pour un monorepo, ce qui noie Claude Code dans un contexte trop large.

Question 26 : Quand faut-il utiliser Claude Code plutôt qu'un IDE avec copilot intégré ?

Réponse modèle : Claude Code excelle sur les tâches de refactoring multi-fichiers, l'analyse de codebase et les opérations Git complexes. Un copilot d'IDE est préférable pour la complétion inline en temps réel. En pratique, 72 % des développeurs utilisent les deux outils de manière complémentaire selon une enquête Stack Overflow (2025).

La page d'introduction Claude Code détaille les cas d'usage optimaux pour chaque approche.

Piège courant : opposer les deux outils au lieu de les combiner dans un workflow complémentaire.

Question 27 : Comment mettre en place une stratégie de prompt engineering d'équipe avec Claude Code ?

Réponse modèle : Centralisez les patterns de prompts éprouvés dans le CLAUDE.md du projet. Documentez les templates pour les tâches récurrentes (génération de tests, refactoring, revue de code). Partagez les résultats via des sessions de pair-programming avec Claude Code. En 2026, les équipes qui standardisent leurs prompts constatent une réduction de 55 % de la variabilité dans la qualité du code généré.

Points-clés à mentionner :

• CLAUDE.md comme référentiel de prompts
• Templates pour tâches récurrentes
• Retour d'expérience en équipe
• Métriques de qualité (taux d'acceptation, temps de revue)

Piège courant : laisser chaque développeur réinventer ses prompts sans capitaliser sur les apprentissages collectifs.

À retenir : le niveau senior évalue votre capacité à déployer Claude Code à l'échelle - CI/CD, sécurité, architecture d'équipe et stratégie organisationnelle.

Comment préparer efficacement un entretien Claude Code ?

Voici une méthode en cinq étapes pour maximiser vos chances :

1. Installez Claude Code et pratiquez 2 heures minimum avec les commandes de base
2. Configurez un CLAUDE.md sur un projet personnel pour comprendre le système de mémoire
3. Testez les trois modes de permission sur des scénarios réels
4. Explorez le mode headless avec un script CI/CD simple
5. Documentez vos apprentissages - les recruteurs valorisent l'expérience pratique

SFEIR Institute propose la formation Claude Code d'une journée pour acquérir les fondamentaux en conditions réelles avec des labs pratiques. Pour aller plus loin, la formation Développeur Augmenté par l'IA de deux jours couvre l'intégration de Claude Code dans un workflow de développement professionnel complet. Les profils seniors gagneront à suivre le niveau Développeur Augmenté par l'IA – Avancé qui aborde les architectures MCP et les stratégies d'équipe en une journée intensive.

À retenir : la pratique concrète sur votre propre environnement reste le meilleur investissement pour réussir un entretien technique sur Claude Code.

Quels sont les pièges les plus fréquents en entretien Claude Code ?

Les candidats commettent souvent les mêmes erreurs. Évitez ces cinq pièges récurrents :

• Confondre Claude Code avec un chatbot : c'est un agent autonome avec accès au système de fichiers, pas un simple assistant conversationnel
• Ignorer les permissions : tout recruteur senior vérifiera votre compréhension du modèle de sécurité
• Négliger CLAUDE.md : ce fichier est central dans l'usage professionnel de Claude Code
• Oublier le coût : chaque interaction consomme des tokens API facturés - la gestion des coûts est un sujet d'entretien fréquent
• Surestimer l'automatisation : Claude Code est un outil d'augmentation, la supervision humaine reste indispensable

les candidats qui démontrent une expérience pratique avec Claude Code ont un taux de réussite 3 fois supérieur à ceux qui se limitent à la théorie. Vérifiez vos connaissances avec les bonnes pratiques de sécurité avant votre entretien.

À retenir : maîtrisez les fondamentaux (installation, permissions, mémoire) avant d'aborder les sujets avancés - un candidat solide sur les bases impressionne plus qu'un candidat superficiel sur tout.