Types, generics, utility types, narrowing, tsconfig strict, generics avancés, zod.
Avant de démarrer, on fait un test technique de 1 min — micro, bruit, connexion. Si ton matériel ne convient pas, le test est remboursé intégralement.
Prouve que ton TypeScript va au-delà des annotations de base : generics avancés, narrowing, Zod, tsconfig strict — un oral IA de 15 minutes pour décrocher un badge qui parle à n'importe quel recruteur tech.
Le badge TypeScript Plume certifie ta maîtrise réelle du système de types de TypeScript, pas juste ta capacité à annoter des variables. L'oral IA explore les zones qui distinguent un développeur junior d'un senior : conditional types, mapped types, discriminated unions, type predicates, exhaustiveness checking avec `never`, et la configuration `strict` du tsconfig. Tu es interrogé comme dans un vrai entretien technique, sur des sujets que tu rencontres en production.
Ce qui rend ce badge crédible, c'est que tu ne peux pas le préparer en cochant des QCM. L'IA examinatrice creuse : elle rebondit sur tes réponses, te demande de décrire un utility type custom que tu as réellement écrit, de justifier un choix entre `unknown` et `any`, ou d'expliquer pourquoi tu as branché Zod plutôt que de faire confiance aux types à la frontière de l'API. Le transcript est ensuite évalué par Claude Opus, qui produit un score 0-100 avec un niveau (Novice / Confirmé / Avancé / Expert) et un rapport détaillé.
Ce badge est taillé pour les développeurs frontend, fullstack et backend qui travaillent avec TypeScript au quotidien et veulent en apporter la preuve. Il intéresse particulièrement ceux qui postulent à des postes où TypeScript est au cœur du stack (React, Next.js, NestJS, tRPC, Prisma), ceux qui reviennent de missions en freelance et ont besoin de se différencier, ou encore les développeurs seniors qui veulent valider leur expertise avant de prétendre à un rôle de tech lead.
Voici les dimensions concrètes que l'IA examine pendant les 15 minutes d'oral.
Écriture de utility types custom (DeepPartial, PathsOf<T>, Flatten), maîtrise des contraintes `extends`, inférence avec `infer`, et paramètres de type const introduits dans TypeScript 5.x.
Discriminated unions, type predicates (`x is Foo`), assertion functions, et exhaustiveness checking avec `never` pour garantir qu'un switch couvre tous les cas possibles d'une union.
Utilisation de `extends ? :` pour des types conditionnels, `keyof`, `in`, `as` dans les mapped types, et combinaison des deux pour des transformations de types complexes.
Activation et justification de chaque option du mode strict (`strictNullChecks`, `noImplicitAny`, `exactOptionalPropertyTypes`), et configuration d'ESLint avec `@typescript-eslint` pour un codebase sans compromis.
Intégration de Zod ou Valibot à la frontière des API et des données externes, inférence du type TS depuis le schéma avec `z.infer<>`, et gestion des erreurs de validation de façon type-safe.
Automatisation de la génération de types depuis OpenAPI (openapi-typescript), GraphQL (GraphQL Code Generator) ou Prisma, pour garder les types synchronisés avec la source de vérité.
Stratégie de migration progressive (`allowJs`, `.d.ts` manuels, `@ts-check`), gestion de la dette technique et des packages sans types, et choix entre `any` temporaire assumé et sur-engineering de types.
Connaissance des évolutions récentes : opérateur `satisfies`, const type parameters, isolatedDeclarations, et capacité à positionner TypeScript par rapport à Flow ou aux propositions de type natif en JavaScript.
L'évaluation finale est faite par Claude (Anthropic) qui relit la transcription complète et applique cette grille de critères pondérés.
Profondeur de compréhension des generics, conditional types, mapped types, et du narrowing. Capacité à décrire des types complexes que tu as réellement écrits, pas juste des exemples issus de la documentation.
Pertinence des exemples issus de vrais projets : migrations, intégration dans une chaîne de build, choix entre Zod et une autre lib de validation, gestion d'une API externe sans types disponibles.
Capacité à justifier un choix technique : quand utiliser `unknown` plutôt qu'`any`, quand un utility type devient contre-productif, pourquoi activer `exactOptionalPropertyTypes` peut casser une codebase existante.
Maîtrise de la configuration tsconfig (projet references, paths, composite), intégration avec les linters, bundlers (Vite, esbuild, tsx) et générateurs de types depuis des sources externes.
Connaissance des dernières releases TypeScript (4.9 satisfies, 5.x const type parameters, 5.5 inferred type predicates), et positionnement par rapport aux alternatives actuelles.
Une session Plume tient en environ 20 minutes, du test technique à la délivrance du badge.
L'IA s'assure que ton micro est fonctionnel, que l'audio est clair et que la connexion est stable. Aucun IDE ni partage d'écran requis : l'oral est entièrement verbal, comme un vrai entretien téléphonique.
Tu te présentes brièvement et tu décris ton utilisation la plus récente ou la plus complexe de TypeScript — un projet, une codebase, une migration. L'IA calibre le niveau de la suite en fonction de ce que tu partages.
L'IA t'interroge sur les dimensions clés : generics avancés, narrowing, conditional types, Zod, tsconfig strict, migrations JS-TS. Elle rebondit sur tes réponses, demande des exemples concrets, et sonde les zones grises — les cas où tu as fait un compromis et pourquoi.
L'IA te donne la parole : as-tu une opinion sur `satisfies`, sur les types natifs en JS, ou sur une limite de TypeScript que tu contournes régulièrement ? C'est ta chance de montrer ta veille et ta maturité technique.
Claude Opus analyse le transcript, produit un score 0-100, un niveau (Novice à Expert) et un rapport écrit détaillé. Ton badge TypeScript est disponible dans ton profil Plume, avec une URL partageable.
Le score sur 100 se traduit en un niveau lisible d'un coup d'œil par un recruteur.
Tu utilises TypeScript comme du JavaScript annoté : types primitifs, interfaces simples, quelques generics copiés-collés depuis Stack Overflow. Le compilateur en mode strict te fait peur et tu mets des `any` pour avancer. Tu n'as pas encore de projet TypeScript en production à ton actif.
Tu travailles avec TypeScript au quotidien sur un projet en production. Tu maîtrises les utility types standards (`Partial`, `Pick`, `Omit`, `Record`), tu comprends le narrowing de base avec les type guards, et tu sais configurer un tsconfig raisonnable. Les generics simples ne te posent plus de problème, mais les conditional types et les mapped types restent flous.
Tu écris des utility types custom, tu maîtrises les conditional types (`infer`, `extends`), les discriminated unions avec exhaustiveness checking, et tu sais brancher Zod ou Valibot pour valider les données à la frontière. Tu as participé à au moins une migration JS-TS non triviale et tu sais configurer `@typescript-eslint` de façon opiniâtre.
Tu conçois des systèmes de types complexes que tes collègues utilisent sans en voir la complexité. Tu connais les subtilités de la variance, les limites du structural typing, les cas où TypeScript perd l'information de type, et tu as une opinion tranchée sur `satisfies`, isolatedDeclarations, ou les type stripping natifs. Tu es souvent la personne de référence TypeScript dans ton équipe.
Pas besoin d'années d'expérience ou de diplôme pour passer le badge. Voici les profils pour qui il fait sens.
Tu utilises TypeScript tous les jours avec React, et tu veux prouver que tu vas au-delà des props typées — que tu maîtrises les generics de hooks, les types de retour de `useReducer`, et la validation des params de route avec Zod.
Un badge TypeScript Expert ou Avancé sur ton profil Plume est un signal fort pour les clients qui recrutent sur des stacks NestJS, tRPC ou Prisma. Il compense l'absence de références vérifiables sur des projets confidentiels.
Tu veux décrocher un poste senior ou lead, et les recruteurs te demandent de prouver ta profondeur TypeScript. L'oral Plume simule exactement le type de questions techniques qu'on te posera en entretien.
Tu fais la transition JS vers TS et tu veux valider que ton niveau est réellement au niveau Confirmé ou Avancé avant de postuler. Le rapport détaillé t'indique précisément les zones à combler.
Tu veux objectiver le niveau TypeScript de ton équipe avant un chantier de migration ou de refactoring. Les badges Plume donnent un référentiel commun sans passer par des entretiens internes chronophages.
Où et comment ton badge TypeScript va te servir au quotidien.
Un recruteur voit "TypeScript" sur ton LinkedIn comme sur 80% des profils. Avec un badge Plume niveau Expert, tu sortis du lot : il peut écouter l'extrait audio, lire le rapport, et voir que tu sais parler de `infer`, de discriminated unions et de Zod en contexte réel.
Un client hésite entre deux freelances. Tu as un badge TypeScript Avancé qui montre que tu sais configurer un projet tRPC avec validation Zod end-to-end et tsconfig strict. L'autre candidat n'a que ses propres mots.
Tu passes l'oral Plume avant ton vrai entretien chez une scale-up. Le rapport identifie que tu es flou sur les assertion functions et `never`. Tu corriges le tir en une semaine et tu arrives en entretien avec bien plus de confiance.
Tu te positionnes comme référent TypeScript pour piloter la migration d'un monorepo JavaScript. Le badge valide ta légitimité auprès du CTO et des autres développeurs, même si tu n'as pas encore le titre de tech lead.
Tu ajoutes l'URL de ton badge Plume dans le README de ta librairie TypeScript open source. Les contributeurs et les employeurs potentiels peuvent vérifier ton niveau en 30 secondes, sans te faire confiance sur parole.
Un CTO veut savoir si son équipe est prête à adopter des generics avancés et Zod avant de lancer un refactoring. Il utilise les badges Plume pour cartographier les niveaux TypeScript de chaque développeur et prioriser les formations.
Quelques minutes pour vérifier que tu as bien tout ce qu'il faut.
À la fin de ta session, tu ne reçois pas juste un score : voici tout ce qui t'attend.
Tu reçois un score précis sur 100 et un niveau (Novice, Confirmé, Avancé ou Expert) qui reflète fidèlement ta maîtrise réelle de TypeScript — pas une auto-évaluation, mais un verdict IA basé sur ton oral.
Claude Opus génère un rapport écrit qui détaille tes points forts (ex : excellente maîtrise des discriminated unions) et tes axes d'amélioration (ex : usage de `infer` à approfondir) — concret et directement exploitable.
L'intégralité de ton oral est enregistré et stocké de façon sécurisée. Tu peux le réécouter pour analyser tes réponses et préparer ton prochain entretien TypeScript avec un retour ultra-précis.
Une URL unique et vérifiable à coller sur ton CV, LinkedIn, GitHub ou portfolio. Les recruteurs et clients peuvent consulter ton score et ton niveau TypeScript sans compte Plume — en 30 secondes, zéro friction.
Découvre d'autres compétences proches que tu peux faire valider avec Plume.
15 minutes d'oral avec une IA, un badge partageable pour tes recruteurs.
Choisir ce badge · 19,99 €
