Maîtriser les agents IA en dev : Les Git Hooks qui changent tout

Les agents IA codent des features en un clin d'œil. Super pratique. Mais sans règles, ils génèrent du code monstrueux. Fichiers de 2000 lignes, boucles infinies, historique Git illisible. Résultat : une dette technique explosive. Et ton équipe qui râle.

La parade ? Des Git hooks partagés qui filtrent tout avant le commit.

Le chaos des IA sans limites

Laisse Claude ou Copilot s'emballer, et voilà ce qui arrive :

• Fichiers obèses qui enfreignent toutes les bonnes pratiques
• Logique tordue impossible à déboguer
• Commits foireux qui polluent l'historique
• Astuces pour contourner les vérifs avec --no-verify

Ces IA veulent bien faire. Mais sans cadre, elles priorisent la vitesse sur la qualité.

Git Hooks : Ton pare-feu qualité

Les Git hooks ? Des scripts auto qui s'exécutent à des moments clés. Comme un vigile qui bloque les intrus à l'entrée du repo.

Deux outils phares simplifient le job :

1. pre-commit — Standard pour Python et projets multi-langages
2. husky — Idéal JS, s'intègre à npm, ultra-simple

Exemple de config béton :

Règles clés anti-IA déchaînée

# Config pre-commit type
repos:
  - repo: local
    hooks:
      - id: limite-lignes
        name: Max lignes par fichier
        entry: python -c "import sys; assert len(open(sys.argv[1]).readlines()) < 600"
        language: system
        types: [python]
      
      - id: check-complexite
        name: Limite McCabe
        entry: flake8 --max-complexity=10
        language: system
        types: [python]

Pourquoi ces seuils ?

• 600 lignes max — Bloque les vidages massifs, OK pour du code légit
• Complexité McCabe à 10 — Garde les fonctions simples et testables

L'IA foire ? Le hook bloque. Pas de commit. Obligé de refactorer sur place.

Outils pour que l'IA se corrige seule

Pour respecter les règles, les agents doivent refactorer auto :

Python : rope excelle. Il extrait des fonctions, renomme, découpe les modules. Parfait pour slim down les gros fichiers.

TypeScript/JS : ts-morph manipule l'AST. Les IA l'utilisent pour repenser l'architecture en live.

Tout se fait par code. L'IA s'auto-améliore.

La charte des agents : Tes règles en clair

Crée un AGENTS.md dans le repo. C'est le contrat :

# Règles pour les agents IA

## Discipline des commits
- Commits courts et descriptifs, pas un blob par tâche
- Ajoute le ticket : "feat(login): Rotation token OAuth [#456]"
- Explique le pourquoi, pas juste le quoi

## Installation hooks
- `git config core.hooksPath .husky` avant tout
- Teste localement, jamais de push foireux

## Règle d'or
- **PAS de `--no-verify` sans feu vert explicite**
- Ça saute toutes les sécurités

## Approche code
- TDD pur : Test rouge → Vert → Refactor
- Écris le test qui plante d'abord
- Passe-le, puis nettoie

Pas de dictature. Juste de la transparence. Les IA cartonnent avec ça.

Pourquoi ton équipe adore

Les devs humains détestent le code poubelle. Avec ces hooks :

✅ Confiance totale — Main branch toujours clean
✅ Reviews fluides — Focus sur le sens, pas les bugs basiques
✅ Onboarding rapide — Standards visibles dès le départ
✅ IA qui progresse — Elle s'adapte aux règles

Checklist pour démarrer

1. Choisis ton framework — pre-commit Python, husky JS (ou les deux)
2. Fixe des limites réalistes — 600 lignes, complexité 10, adapte à ton code
3. Intègre les refactor tools — rope ou ts-morph dans l'arsenal IA
4. Documente — AGENTS.md avec explications
5. Déploie soft — Warnings d'abord, blocks après
6. Surveille — Ajuste si trop de fails

La vraie leçon

Oublie le blocage pur. Crée un écosystème où le bon code est facile. Hooks + docs + tools = IA qui génère du propre naturellement. Elle découpe, simplifie, commit bien.

L'IA passe de risque à booster d'équipe.

Chez NameOcean, on kiffe l'infra qui scale : domains solides, hosting cloud, workflows dev blindés. Traite ton code comme ton infra. Git hooks en première ligne. Ton futur toi te dira merci.