Retour au blog
TypeScriptMarch 28, 202610 min de lecture

J'ai créé un vérificateur de types qui empêche l'IA de me mentir

L'IA utilisera `any` pour échapper à une erreur de type. Elle ajoutera eslint-disable. Elle vous mentira. Voici comment nous avons réparé la boucle de feedback.

L'IA ne vous ment pas parce qu'elle le veut. Elle vous ment parce que vous la laissez faire.

La boucle de feedback cassée

Demandez à Claude Code d'ajouter une fonctionnalité. Il le fait. Lancez ESLint : ça passe. Lancez TypeScript : erreurs. Demandez à Claude Code de corriger le TypeScript. Il le fait. Relancez ESLint : maintenant c'est lui qui échoue. Des allers-retours. Trois itérations. L'IA est sûre d'elle à chaque étape. À chaque fois : « C'est corrigé. »

Ça n'a jamais été corrigé.

C'était un jeu de la taupe avec un outil qui lance un linter à la fois et ne voit jamais l'ensemble.

L'IA corrige l'erreur TypeScript en écrivant une seule ligne et vous dit : « L'erreur de type est résolue. »

typescript
const result = data as unknown as MyExpectedType;

Oui. Techniquement. Comme on « résout » une alarme incendie en scotchant le détecteur de fumée.

C'est exactement ce que @next-vibe/checker est là pour empêcher.

Le problème de `any`

Pourquoi 98 % de sûreté des types revient à 0 %

Le système de types de TypeScript est un graphe. Chaque type circule de sa définition à son usage. Si une fonction renvoie `string`, l'appelant sait que c'est une string. Toute la chaîne est vérifiée.

any
result
transformed
output
Component
hook
schema

Un seul type `any` se propage dans le graphe et corrompt l'inférence de types en aval

`any` est un trou dans le graphe.

Une variable typée `any` dit au compilateur : arrête de vérifier ici. Pas seulement pour cette variable, mais pour tout ce qui la touche. L'erreur n'apparaît pas au niveau du `any`. Elle apparaît trois fichiers plus loin, quand un refactoring sans rapport casse une hypothèse qui n'a jamais été vérifiée.

0

Erreurs TypeScript

47

Usages de `any`

Zéro erreur TypeScript ne veut rien dire si vous avez 47 usages de `any` non vérifiés.

`as unknown as Whatever`, c'est pire. C'est une double assertion de type. Vous dites au compilateur : je sais que c'est faux, et je force le passage quand même. C'est l'échappatoire préférée de l'IA.

Les motifs interdits dans ce code :

anyno-explicit-any
as unknown asno-unsafe-assignment
@ts-expect-errorban-ts-comment
throwrestricted-syntax
unknownrestricted-syntax
objectrestricted-syntax

Pas des avertissements. Des erreurs. La vérification échoue. Claude Code doit corriger la cause profonde, sinon il ne peut pas livrer.

Si ce sont des erreurs et non des avertissements, c'est autant pour des raisons psychologiques que techniques. Les modèles d'IA traitent les avertissements comme facultatifs. Les erreurs ferment la boucle.

Voici @next-vibe/checker

Une commande. Trois outils. Aucune échappatoire.

bash
$ vibe check

Voilà la commande. Une seule. Elle lance trois outils en parallèle et vous donne une liste d'erreurs unifiée.

Oxlint

Linter écrit en Rust. Des centaines de règles. S'exécute en quelques millisecondes, même sur de grosses codebases.

ESLint

Ce qu'Oxlint ne fait pas encore : lint des hooks React, règles du React Compiler, tri des imports.

TypeScript

Vérification de types complète. Pas seulement le fichier que vous éditez : tout le graphe.

en parallèle

Liste d'erreurs unifiée

Une seule sortie. On corrige jusqu'à ce que ce soit propre.

Sur ce code (4 400 fichiers), TypeScript complet prend environ 12 secondes. Oxlint, moins d'une seconde. ESLint, quelques secondes. En parallèle, on tombe à 12.

Il propose aussi une commande `vibe-check mcp` qui démarre un serveur MCP avec un outil `check`. L'IA ne lance pas de commande shell : elle appelle un outil qui renvoie des erreurs structurées. Pagination intégrée. Filtrage par chemin.

Plugins maison

Le linter, c'est la documentation. Et elle est appliquée.

Plugin jsx-capitalization

Il signale les éléments JSX en minuscules, et le message d'erreur dit exactement quoi importer à la place :

<button><Button> from "next-vibe/ui/components/button"
<a><Link> from "next-vibe/ui/components/link"
<p><P> from "next-vibe/ui/components/typography"

Je n'ai écrit aucune documentation pour dire à Claude Code d'utiliser `next-vibe-ui`. Je ne l'ai pas mis dans le prompt système. La première fois que Claude Code écrit `<div>` dans un composant, le vérificateur lève une erreur. Le message contient le chemin d'import exact. Claude Code lit l'erreur, applique la correction et retient la convention.

Plugin restricted-syntax

Il interdit trois choses :

Les instructions `throw`

Le message d'erreur dit : « Use proper `ResponseType<T>` patterns instead. » Claude Code tombe dessus, le lit, va voir `ResponseType` et adopte le bon modèle de gestion d'erreurs pour tout le reste de la tâche.

Le type `unknown` nu

« Replace 'unknown' with existing typed interface. Align with codebase types rather than converting or recreating. » Cela empêche Claude Code d'écrire des échappatoires de type génériques.

Le type `object` nu

`object` est presque toujours faux. Soit vous connaissez la forme, et vous écrivez l'interface, soit vous avez un `Record<string, SomeType>`. Un `object` brut, c'est le signe que l'IA a abandonné.

Motifs interdits

INTERDITrestricted-syntax
typescript
const result = response as unknown as MyType;
CORRECT
typescript
const result: MyType = parseResponse(response);
INTERDITno-explicit-any
typescript
function foo(x: any): any { return x.data; }
CORRECT
typescript
function foo<T>(response: ResponseType<T>): T | null {
  if (!response.success) return null;
  return response.data;
}
INTERDITrestricted-syntax
typescript
throw new Error("Something failed");
CORRECT
typescript
return fail({
  message: t("errors.server.title"),
  errorType: ErrorResponseTypes.INTERNAL_ERROR,
});

Démo en direct : le schéma en 3 tours

Regardez Claude Code buter trois fois sur le vérificateur avant de trouver le bon type

1

Tour 1 : l'IA écrit `any`

Demandez à Claude Code : « Écris une fonction utilitaire qui prend un objet de réponse d'API brut et en extrait le champ data. La réponse peut avoir différentes formes : utilise le type qu'il faut pour que ça marche. »

Claude Code écrit la solution facile :

typescript
export function parseApiResponse(response: any): any {
  return response.data;
}
vibe check
bash
  1:37  error  Unexpected any.  typescript/no-explicit-any
  1:44  error  Unexpected any.  typescript/no-explicit-any

2 errors found.
2

Tour 2 : l'IA tente `unknown`

Regardez ce qu'il fait ensuite. C'est le moment important. Il tente la sortie de secours suivante :

Le vérificateur connaît ce tour-là.

typescript
export function parseApiResponse(response: unknown): unknown {
  return (response as Record<string, unknown>).data;
}
vibe check
bash
  1:37  error  Replace 'unknown' with typed interface.  restricted-syntax
  1:44  error  Replace 'unknown' with typed interface.  restricted-syntax
  1:56  error  Replace 'unknown' with typed interface.  restricted-syntax

3 errors found.
3

Tour 3 : l'IA trouve le vrai type

Claude Code fait enfin ce qu'il aurait dû faire d'emblée. Il regarde comment les réponses d'API existantes sont typées dans ce code. Il trouve `ResponseType<T>`.

Zéro erreur. Et la fonction est maintenant vraiment correcte.

typescript
import type { ResponseType } from "next-vibe/core/route/response.schema";

export function parseApiResponse<T>(
  response: ResponseType<T>
): T | null {
  if (!response.success) return null;
  return response.data;
}
vibe check
bash
  Oxlint: 0 errors
  ESLint: 0 errors
  TypeScript: 0 errors

0 errors found.

Ce n'est pas le vérificateur qui l'a écrite. Mais il a bloqué le raccourci, deux fois, jusqu'à ce que Claude Code doive s'attaquer au vrai problème.

Le lien avec les endpoints

Un schéma Zod, quatre consommateurs en aval

Chaque endpoint a un fichier de définition. Ce fichier contient un schéma Zod pour la requête et un pour la réponse.

La clé `schema` est un validateur Zod. Ce même schéma Zod devient :

typescript
name: requestField(st, {
  schema: z.string().min(1).max(255),
  label: "name",
  description: "description",
  placeholder: "placeholder",
}),

La règle de validation de l'endpoint de l'API web

Le type TypeScript du paramètre d'entrée du hook React

Le flag `--name` de la CLI, avec les contraintes min/max appliquées

La description du paramètre dans le schéma de l'outil IA

C'est là que la dérive vous tue d'habitude. Vous mettez à jour l'API. Vous oubliez le schéma de l'outil IA. L'IA appelle l'endpoint avec les anciens noms de paramètres. Ça échoue en silence.

Avec un seul schéma, il n'y a rien à synchroniser.

Et comme le vérificateur TypeScript tourne aussi là-dessus, si vous modifiez le schéma d'une façon qui casse le type inféré en aval, vous obtenez une erreur de compilation. Le schéma de l'outil IA est vérifié. Les flags de la CLI sont vérifiés. Le hook React est vérifié.

245

245 endpoints

0

Zéro `any`

0

Zéro cast `unknown`

0

Zéro `@ts-expect-error`

Pas par convention. Par le vérificateur.

Obtenir @next-vibe/checker

Fonctionne sur n'importe quel projet TypeScript. Pas seulement next-vibe.

Le vérificateur existe en paquet npm autonome. Il fonctionne sur n'importe quel projet TypeScript, pas seulement NextVibe. Vous n'avez besoin d'aucune autre partie du framework.

bash
bun add -D @next-vibe/checker\n# or\nnpm install -D @next-vibe/checker

Puis lancez :

bash
vibe-check config    # scaffold check.config.ts\nvibe-check           # run all checks\nvibe-check --fix     # auto-fix linting issues

Intégration MCP

Ajoutez-le à votre config MCP de Claude Code ou de Cursor. Claude Code appelle alors `check` comme un outil, pas comme une commande shell. Erreurs structurées. Paginées. Filtrables par chemin.

json
{
  "mcpServers": {
    "vibe-check": {
      "command": "vibe-check",
      "args": ["mcp"],
      "env": { "PROJECT_ROOT": "/path/to/project" }
    }
  }
}

La page npm propose aussi un prompt de migration. Copiez-le dans Claude Code ou Cursor : il audite votre code, configure le vérificateur et vous fait migrer vers les règles d'interdiction.

C'est open source. GPL-3.0 pour le framework, MIT pour le paquet du vérificateur.

Construisez le système pour que mentir soit impossible

Avant :

Le développement assisté par IA était une négociation. Corriger le lint. Ah, maintenant les types cassent. Corriger les types. Maintenant il y a un `any` que vous n'aviez pas vu. Le corriger. Trois outils séparés à lancer. Trois avis séparés. Jamais sûr que ce soit vraiment propre.

Après :

Une commande. Un seul mode d'échec. Soit ça passe, soit non. L'IA sait exactement quoi corriger, parce que les erreurs lui disent précisément ce qui ne va pas et quoi faire à la place. Aucune négociation.

Construisez le système pour que mentir soit impossible. C'est à ça que sert un vérificateur de types.

Retour au blog