scale-check

Audit read-only de la base de code en 7 points : index et requêtes dans les boucles, mise en cache partagée des lectures, exécution en deux instances, ralentissements dans les requêtes web, sauvegardes et restauration, mise en cache publique vs privée, et limites de débit sur les endpoints publics ou payants.

Qu'est-ce que scale-check ?

Scale Check est un skill d'audit de préparation à la production en lecture seule pour les agents de codage comme Claude Code. Il inspecte la base de code selon sept questions clés de scalabilité : (1) présence d'index et de requêtes dans les boucles (problème N+1), (2) lectures partagées répétées sans mise en cache, (3) état en mémoire ou sur disque local qui empêche l'exécution en deux copies, (4) traitements lents et synchrones dans les requêtes web, (5) sauvegardes et procédure de restauration, (6) séparation entre mise en cache des assets publics et des données privées, et (7) limites de débit sur les endpoints publics ou payants. Le skill est déclenché en mode plan (lecture seule) via `/scale-check`, avec un argument optionnel pour cibler un dossier ou une route spécifique. Il produit un rapport structuré avec un tableau de bord par question, des extraits de code localisés (fichier:ligne) et un plan de correction priorisé, en commençant par les sauvegardes et les limites de débit. Il prend soin de préciser que les analyses sont des pistes à vérifier et non des bugs garantis, et qu'il ne modifie jamais la base de code. Le skill est compatible avec tout projet web (Node, Python, Go, etc.) et tout ORM/base de données, et s'appuie sur l'inspection statique de fichiers pour identifier les problèmes de scalabilité potentiels.

Compatible avec✓Claude Code✓Codex CLI~Cursor
npx skills add https://github.com/eboywonder/missing-readme-skills/tree/main/scale-check

Installed? Explore more Développement et programmation skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Scale Check – Audit de préparation à la production en 7 points

Vous exécutez /scale-check en mode plan lecture seule. Votre travail consiste à inspecter la base de code par rapport aux 7 questions de mise à l'échelle ci-dessous et à afficher un plan de vérification et de correction clair et priorisé à l'écran de l'utilisateur.

Scope cible : $ARGUMENTS (Si vide, auditez l'ensemble du dépôt).


Règles impératives (à lire avant l'analyse)

  1. Regardez, ne modifiez pas : Vous êtes strictement en mode diagnostic et planification. Ne créez, modifiez ni ne supprimez aucun fichier. N'exécutez pas de migrations de base de données, de commandes modifiant l'état, ni de requêtes réseau.
  2. Les constats sont des pistes à vérifier, pas des faits : L'analyse statique d'un dépôt ne peut pas voir les tableaux de bord cloud externes, les règles CDN, les politiques WAF ou les paramètres de base de données gérée. Présentez chaque problème que vous repérez comme une piste à vérifier, jamais comme un bug garanti.
  3. Citez toujours les emplacements exacts : Chaque piste de code doit inclure chemin/vers/fichier:ligne et le symbole ou la requête spécifique impliquée. Si quelque chose manque dans la base de code, rapportez-le explicitement : "Introuvable dans le dépôt — vérifiez dans votre fournisseur d'hébergement/cloud."
  4. Corrigez un à la fois, en commençant par la survie : Ordonnez toujours le plan de correction final en commençant par les Sauvegardes (Question 5) et la Limitation de débit (Question 7), puis les éventuelles fuites de données privées via un cache partagé (Question 6) , puis les questions restantes dans l'ordre où elles affectent généralement une application en croissance : index et boucles (Q1), lectures partagées (Q2), exécution en deux copies (Q3), travaux lents dans les requêtes (Q4) et mise en cache des assets publics (le reste de Q6).

Workflow d'exécution

Phase 1 : Identifier la stack (passage rapide)

Avant de vérifier les 7 questions, identifiez rapidement la stack du projet pour savoir où chercher :

  • Manifestes & Frameworks : Vérifiez package.json, pyproject.toml, requirements.txt, go.mod, Cargo.toml ou Gemfile.
  • Base de données & ORM : Localisez schema.prisma, les fichiers de schéma Drizzle, les modèles TypeORM/Sequelize, les fichiers SQLAlchemy/Alembic, Django models.py, ou les migrations .sql brutes.
  • Points d'entrée & Routes : Localisez les routes API (app/api/, pages/api/, src/routes/, controllers/, routers/, main.py, cmd/).
  • Infrastructure & Configuration : Vérifiez Dockerfile, docker-compose.yml, vercel.json, next.config.*, fly.toml, render.yaml, nginx.conf, .github/workflows/ et README.md.

Phase 2 : Examiner les 7 questions

Effectuez des passes ciblées Glob, Grep et Read pour chacune des 7 questions ci-dessous. Ne sautez aucune question.


Les 7 questions

Question 1 : Index & requêtes dans les boucles

  • Format court de la fiche : "Pages qui recherchent ou listent des données : les colonnes sont-elles indexées, et y a-t-il une requête dans une boucle ?"
  • Question de diagnostic complète : Où l'application liste, filtre, trie ou recherche des enregistrements, les colonnes sous-jacentes de la base de données (WHERE, JOIN, ORDER BY, clés étrangères) sont-elles soutenues par des index dans le schéma, et un endpoint quelconque exécute-t-il une requête de base de données ou d'API dans une boucle (le problème N+1) ou récupère-t-il des lignes non bornées sans pagination ?
  • Où et comment chercher :
    • Schéma vs. Requêtes : Comparez les requêtes de liste/recherche (findMany, select, filter, WHERE, ILIKE, ORDER BY) avec les définitions d'index (@@index, index(), CREATE INDEX, db_index=True). Notez que Prisma/SQLAlchemy n'indexent souvent pas automatiquement les clés étrangères ou les colonnes de tri sauf déclaration explicite.
    • Boucles avec E/S : Recherchez dans les gestionnaires de routes et les fonctions de service les for (, for await, .map(async, forEach(async, ou les compréhensions de listes qui appellent db., prisma., supabase., session.execute, ou fetch( à l'intérieur du corps de l'itération.
    • Lectures non bornées : Vérifiez si les endpoints de liste imposent une limite take / limit ou si une seule requête peut charger une table entière en mémoire.
  • Ce qui pourrait être en dehors du dépôt (vérification de faux positif) :
    • Les index peuvent avoir été créés manuellement dans des consoles SQL de production sans être commités dans les fichiers de migration.
    • Les petites tables de recherche (ex. <50 rôles ou catégories statiques) ne seront pas un goulot d'étranglement sur un index manquant, mais les boucles N+1 sur des données générées par l'utilisateur le seront.

Question 2 : Lectures partagées répétées

  • Format court de la fiche : "Requêtes de lecture qui s'exécutent souvent et renvoient le même résultat pour tout le monde."
  • Question de diagnostic complète : Quelles requêtes de lecture à fort trafic calculent ou récupèrent exactement les mêmes données publiques pour chaque visiteur à chaque requête – comme les flux de page d'accueil, les catalogues de produits, la configuration globale, les classements ou les compteurs publics – sans mettre en cache le résultat en mémoire, Redis/KV ou le cache de données du framework ?
  • Où et comment chercher :
    • Inspectez les routes publiques, les pages d'accueil, les chargeurs de mise en page et le middleware global qui sollicitent la base de données primaire à chaque chargement de page sans paramètres spécifiques à l'utilisateur (userId, sessionId, orgId).
    • Recherchez des agrégations coûteuses (COUNT(*), SUM(), jointures multi-tables) exécutées en direct sur des endpoints publics.
    • Cherchez des primitives de cache existantes (unstable_cache, 'use cache', revalidate, Redis get/set, @lru_cache, Cache-Control: s-maxage) pour voir si les lectures partagées sont déjà encapsulées.
  • Ce qui pourrait être en dehors du dépôt (vérification de faux positif) :
    • Un CDN en amont (Cloudflare, CloudFront, Fastly) peut déjà mettre en cache des routes publiques complètes en périphérie via les règles de page du tableau de bord.

Question 3 : Exécution en deux copies (apatridie & stockage local)

  • Format court de la fiche : "L'application pourrait-elle s'exécuter en deux copies, et qu'est-ce qui vit dans la mémoire d'un serveur ou sur son disque ?"
  • Question de diagnostic complète : Si le trafic augmente et que vous démarrez une deuxième instance de serveur derrière un équilibreur de charge (ou déployez dans des instances serverless à mise à l'échelle automatique), qu'est-ce qui se casse parce que l'état est stocké dans la RAM d'un seul processus ou écrit sur le système de fichiers local d'un seul conteneur ?
  • Où et comment chercher :
    • État mémoire en processus : Recherchez new Map(), new Set() au niveau du module, des tableaux/objets mutables globaux, des magasins de session en mémoire (MemoryStore), des compteurs de limite de débit locaux, ou des pub/sub en processus (EventEmitter, Sets WebSocket non pontés) qui supposent que tous les utilisateurs frappent le même processus Node/Python/Go.
    • Dépendance au disque local : Recherchez les écritures de fichiers locales (fs.writeFile, fs.createWriteStream, open(..., 'w'), multer.diskStorage, stockage /tmp ou ./uploads) et les bases de données locales embarquées (sqlite, better-sqlite3, fichiers .db) utilisées pour les données d'exécution mutables.
    • Tâches cron en processus : Vérifiez node-cron, setInterval ou APScheduler démarrés à l'intérieur du point d'entrée principal du serveur web, ce qui déclencherait des tâches en double si deux instances s'exécutent simultanément.
  • Ce qui pourrait être en dehors du dépôt (vérification de faux positif) :
    • Les Maps au niveau du module utilisés strictement comme caches en lecture seule avec un TTL (ou les clients SDK singleton paresseux comme Prisma/Stripe) sont sûrs sur plusieurs instances.
    • Les applications à VPS unique utilisant un volume persistant monté et des sessions persistantes peuvent intentionnellement s'exécuter en tant que nœud unique – signalez clairement le compromis plutôt que de le qualifier de cassé.

Question 4 : Travail synchrone lent dans les requêtes web

  • Format court de la fiche : "Partout où une requête web fait quelque chose de lent, comme un appel IA, un e-mail ou un fichier."
  • Question de diagnostic complète : Où une requête HTTP maintient-elle la connexion de l'utilisateur ouverte en attendant un travail lent, imprévisible ou lourd – comme un appel de génération LLM/IA, l'envoi d'e-mails transactionnels, la génération de PDF, le redimensionnement d'images/vidéos, l'analyse de gros CSV, ou l'enchaînement de plusieurs webhooks tiers – avant de renvoyer une réponse ?
  • Où et comment chercher :
    • Tracez les contrôleurs POST/PUT, les Server Actions et les gestionnaires de webhooks du début de la requête au retour de la réponse.
    • Recherchez les appels await bloquants vers des SDK IA (openai, @anthropic-ai, @google/genai, ai), des fournisseurs d'e-mail (resend, nodemailer, sendgrid, postmark), des processeurs médias/fichiers (sharp, ffmpeg, puppeteer, pdfkit) ou des API externes dans le chemin critique de la requête.
    • Vérifiez si le projet dispose d'une file d'attente en arrière-plan ou d'une configuration de worker asynchrone (bullmq, inngest, trigger.dev, celery, sidekiq, waitUntil) et si les appels lents l'utilisent réellement ou la contournent.
  • Ce qui pourrait être en dehors du dépôt (vérification de faux positif) :
    • Les endpoints IA en streaming (streamText, SSE, réponses segmentées) sont conçus pour rester ouverts tout en diffusant des tokens au client ; signalez-les uniquement s'ils effectuent un pré/post-traitement synchrone lourd ou manquent de limites de timeout.

Question 5 : Sauvegardes, réplicas & chemin de restauration

  • Format court de la fiche : "Quelles sauvegardes ou réplicas existent, où, à quelle fréquence, et comment restaurer. Si ce n'est pas dans le dépôt, dites-le."
  • Question de diagnostic complète : Quelles sauvegardes ou réplicas automatisés de base de données et de stockage existent, où sont-ils stockés, à quelle fréquence s'exécutent-ils, et existe-t-il une procédure documentée et testée pour les restaurer ? Si la configuration de sauvegarde n'est pas visible dans le dépôt, indiquez-le explicitement.
  • Où et comment chercher :
    • Recherchez dans les fichiers d'infrastructure (docker-compose.yml, Terraform .tf, Pulumi, CloudFormation, fly.toml, .github/workflows/, scripts/, Makefile, crontab) pg_dump, mysqldump, sqlite3 .backup, wal-g, litestream, les synchronisations de sauvegarde S3, ou les configurations de réplica.
    • Recherchez dans README.md, CONTRIBUTING.md, docs/ ou runbooks/ toute mention de planifications de sauvegarde, de Point-in-Time Recovery (PITR) ou de commandes de restauration.
  • Règle impérative pour la Question 5 :
    • Dans la plupart des applications modernes utilisant des bases de données gérées (Supabase, Neon, RDS, PlanetScale, Railway, MongoDB Atlas), les paramètres de sauvegarde vivent dans le tableau de bord cloud, pas dans git.
    • Si vous ne trouvez pas de configurations de sauvegarde et d'instructions de restauration dans le dépôt, dites-le clairement : "Aucune configuration de sauvegarde ni runbook de restauration trouvé dans le dépôt. Vérifiez dans le tableau de bord de votre fournisseur de base de données que les sauvegardes automatisées/PITR sont activées, vérifiez la fréquence de rétention et effectuez une restauration test vers une base de données de staging."

Question 6 : Assets publics vs. mise en cache des données privées

  • Format court de la fiche : "Quels fichiers sont les mêmes pour chaque utilisateur, et quels fichiers ne doivent jamais être mis en cache."
  • Question de diagnostic complète : Les fichiers statiques qui sont identiques pour tous les utilisateurs (bundles, polices, images publiques, pages marketing) sont-ils configurés pour être mis en cache agressivement en périphérie CDN/navigateur, et les réponses authentifiées ou spécifiques à l'utilisateur (données de compte, tableaux de bord, facturation, jetons d'authentification) sont-elles strictement protégées contre le stockage dans un cache partagé ?
  • Où et comment chercher :
    • Fuites de cache dangereuses (risque P0) : Vérifiez si une route renvoyant des données personnalisées, un état de session ou un JSON privé définit Cache-Control: public ou s-maxage sans private ou no-store, ou si la mise en cache des routes du framework (export const revalidate = ..., force-static) est accidentellement activée sur une route qui lit les cookies/en-têtes pour un utilisateur spécifique.
    • Assets statiques non mis en cache : Vérifiez next.config.*, vercel.json, nginx.conf, Express static(), ou les assistants de téléchargement S3/CDN pour voir si les assets statiques et les médias publics téléchargés par l'utilisateur définissent des en-têtes Cache-Control immuables ou à longue durée de vie.
  • Ce qui pourrait être en dehors du dépôt (vérification de faux positif) :
    • Les frameworks comme Next.js, Remix et Vite empruntent automatiquement les empreintes digitales et mettent en cache les assets de construction sous /_next/static ou /assets au moment du déploiement, même sans en-têtes personnalisés dans le dépôt.

Question 7 : Endpoints publics et payants (limitation de débit & garde-fous de coût)

  • Format court de la fiche : "Quels endpoints sont publics ou appellent un service payant, et y a-t-il quelque chose qui limite la fréquence à laquelle un utilisateur peut les appeler."
  • Question de diagnostic complète : Quelles routes peuvent être appelées sans authentification (connexion, inscription, liens magiques, réinitialisation de mot de passe, recherche publique, formulaires de contact, webhooks) ou déclenchent un service mesuré/payant (API LLM, SMS/OTP, envoi d'e-mails, stockage de fichiers, API de données payantes), et qu'est-ce qui applique des limites de débit par IP ou par utilisateur, des limites de taille de corps de requête et des limites de dépenses/tokens dans le code ?
  • Où et comment chercher :
    • Inventaire des endpoints à haut risque : Listez toutes les routes publiques d'auth/formulaires et chaque endpoint qui appelle une API externe facturée ou déclenche des écritures DB lourdes.
    • Vérification des limiteurs de débit : Recherchez dans les dépendances et le middleware les bibliothèques de limitation de débit (@upstash/ratelimit, express-rate-limit, rate-limiter-flexible, slowapi, django-ratelimit, rack-attack, golang.org/x/time/rate) et vérifiez si elles sont réellement attachées aux routes risquées.
    • Vérification des limites de saisie et de dépenses : Sur les endpoints IA ou de téléchargement de fichiers, vérifiez si max_tokens / maxOutputTokens, la validation de la longueur du prompt (ex. Zod .max()), et les limites de taille de fichier sont appliquées avant d'appeler le fournisseur.
  • Ce qui pourrait être en dehors du dépôt (vérification de faux positif) :
    • La limitation de débit peut être appliquée en amont via Cloudflare WAF, AWS API Gateway, Vercel Firewall ou un proxy inverse Nginx en dehors du dépôt d'application. Si aucun limiteur dans le dépôt n'existe, signalez-le comme une piste hautement prioritaire à vérifier en amont ou à ajouter dans le middleware.

Format de sortie (Affichez ce plan à l'écran)

Présentez votre rapport en utilisant les sections exactes ci-dessous. Gardez un ton direct, calme et pratique.

1. Aperçu Stack & Scope

  • Stack détectée : [Framework, Langage, DB/ORM, Indices d'hébergement/infra]
  • Scope analysé : [Dépôt complet ou chemin spécifique]
  • Rappel : Ces constats sont des pistes à vérifier, pas des bugs garantis. Les configurations d'infrastructure définies dans les tableaux de bord cloud (sauvegardes DB gérées, règles CDN, limites de débit WAF) n'apparaîtront pas dans git.

2. Tableau de bord des 7 questions

#QuestionStatutMeilleure piste / Observation
Q1Index de recherche/liste & requêtes dans les boucles[PISTE À VÉRIFIER] / [SEMBLE COUVERT]Résumé en 1 ligne
Q2Lectures partagées fréquentes renvoyant les mêmes données[PISTE À VÉRIFIER] / [SEMBLE COUVERT]Résumé en 1 ligne
Q3Exécution en deux copies (état mémoire & disque)[PISTE À VÉRIFIER] / [SEMBLE COUVERT]Résumé en 1 ligne
Q4Travail synchrone lent dans les requêtes web[PISTE À VÉRIFIER] / [SEMBLE COUVERT]Résumé en 1 ligne
Q5Sauvegardes, réplicas & restauration[PISTE À VÉRIFIER] / [INCONNU – VÉRIFIER LE TABLEAU DE BORD]Résumé en 1 ligne
Q6Assets publics vs. mise en cache des données privées[PISTE À VÉRIFIER] / [SEMBLE COUVERT]Résumé en 1 ligne
Q7Limites de débit sur endpoints publics/payants[PISTE À VÉRIFIER] / [SEMBLE COUVERT]Résumé en 1 ligne

3. Références de code détaillées (par question)

Pour chaque question marquée [PISTE À VÉRIFIER], listez les références de code exactes dans un format facile à lire. Utilisez des listes ou des blocs avec code pour montrer les lignes problématiques ou manquantes. Par exemple :

// Fichier : src/api/users.ts:44
// Problème : Requête N+1 à l'intérieur d'une boucle for
for (const userId of userIds) {
  const user = await db.findUser(userId) // Appel DB dans une boucle
}
-- Fichier : prisma/schema.prisma:120
// Constat : Pas d'index sur la colonne "email" utilisée dans WHERE
model User {
  id    Int   @id @default(autoincrement())
  email String // @@index([email]) est manquant
}

Si rien n'est trouvé pour une question marquée [PISTE À VÉRIFIER], indiquez clairement : "Aucune occurrence trouvée dans le scope analysé – vérifiez les dépendances/configuration externes."

4. Plan de correction priorisé

Priorité 0 (Survie) – À corriger en premier

  • Sauvegardes & restauration (Q5) : Détail de ce qui doit être mis en place ou vérifié.
  • Limitation de débit & garde-fous de coût (Q7) : Détail des endpoints non protégés.
  • Fuites de cache privé (Q6) : Détail de toute route risquée.

Priorité 1 – Index, lectures partagées, stateless

  • Index & boucles (Q1) : Détail des correctifs.
  • Lectures partagées répétées (Q2) : Où ajouter un cache.
  • Problèmes de deux copies (Q3) : Dépendances d'état local à migrer.

Priorité 2 – Perf et mise en cache restante

  • Travail lent dans les requêtes (Q4) : Appels bloquants à déplacer en file d'attente.
  • Mise en cache des assets publics (reste de Q6) : En-têtes manquants.

L'analyse est maintenant terminée. Affichez le rapport complet ci-dessus et demandez à l'utilisateur s'il souhaite que vous ouvriez un fichier ou un onglet de terminal spécifique pour approfondir une question particulière.

Skills associés