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. »
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.
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 :
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.
$ vibe checkVoilà 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.
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 :
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
const result = response as unknown as MyType;const result: MyType = parseResponse(response);function foo(x: any): any { return x.data; }function foo<T>(response: ResponseType<T>): T | null {
if (!response.success) return null;
return response.data;
}throw new Error("Something failed");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
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 :
export function parseApiResponse(response: any): any {
return response.data;
} 1:37 error Unexpected any. typescript/no-explicit-any
1:44 error Unexpected any. typescript/no-explicit-any
2 errors found.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à.
export function parseApiResponse(response: unknown): unknown {
return (response as Record<string, unknown>).data;
} 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.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.
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;
} 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 :
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.
bun add -D @next-vibe/checker\n# or\nnpm install -D @next-vibe/checkerPuis lancez :
vibe-check config # scaffold check.config.ts\nvibe-check # run all checks\nvibe-check --fix # auto-fix linting issuesInté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.
{
"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.