Construire une compétence Claude Code qui révise, trie et commite

Il existe un type particulier de culpabilité de développeur qui frappe vers 18h. Vous avez codé tête baissée toute la journée, les choses fonctionnent plus ou moins, mais l'historique Git est un cimetière de commits à moitié terminés. Il y a un TODO enfoui trois fichiers plus loin que vous avez mentalement repéré à 10h et complètement oublié. Le README décrit encore l'architecture d'il y a trois semaines.

Nous voulions résoudre ce problème sans ajouter un outil supplémentaire, un processus supplémentaire, ou une chose de plus à retenir. Tapez une commande en fin de journée, laissez le partenaire de code IA s'occuper du reste.

Voici comment nous avons construit /wrapup — une skill Claude Code qui fait exactement cela.

À quoi ressemble une bonne passation de fin de journée

Un bon wrapup fait cinq choses :

1. Passe en revue ce qui a réellement changé — pas juste un git diff, mais un résumé lisible de ce qui a bougé et pourquoi.
2. Exécute les contrôles qualité — lint, types, tests, un build rapide. Attrape les erreurs embarrassantes avant qu'elles n'arrivent sur GitHub.
3. Maintient la documentation à jour — met à jour CLAUDE.md, le README, un changelog s'il en existe un. Ces choses qui passent toujours à la trappe.
4. Trie les issues ouvertes — scanne les TODOs et les issues GitHub ouvertes, effectue un rapide Q&A sur les éléments importants, rédige un agenda priorisé pour le lendemain matin.
5. Commit et push — automatiquement pour les changements propres ou à faible risque, avec une pause pour revue humaine uniquement quand quelque chose de critique reste non résolu.

Le résultat : un historique Git qui raconte une histoire cohérente, un CLAUDE.md toujours à jour, et un bloc ## Next Session qui fait que demain matin, vous ouvrez le projet en sachant déjà par où commencer.

Comment fonctionne la skill

La skill est un fichier Markdown. C'est véritablement tout ce que c'est. Claude Code le lit, charge les instructions dans le contexte, et les suit quand vous invoquez la commande.

Voici la séquence complète :

Phase 1 — Revue des changements. Exécute git status, git diff HEAD et git log --oneline -10. Produit un résumé en langage clair de ce qui a changé aujourd'hui.

Phase 2 — Contrôles qualité. Détecte la toolchain du projet depuis package.json ou CLAUDE.md et exécute ce qui convient : ESLint ou Ruff pour le linting, tsc --noEmit ou Mypy pour les types, la suite de tests, une vérification du build. Les problèmes mineurs comme des instructions console.log oubliées sont corrigés automatiquement. Les problèmes plus importants sont signalés et documentés comme TODOs plutôt que traités en plein wrapup.

Phase 3 — Mise à jour de la mémoire et de la documentation. Vérifie si quelque chose de nouveau doit être ajouté à CLAUDE.md — nouvelles commandes, conventions, variables d'environnement. Met à jour le README si un comportement côté utilisateur a changé. Ajoute au changelog s'il en existe un.

Phase 3b — Triage des issues et TODOs. C'est la partie que nous trouvons la plus précieuse. Elle effectue un grep dans toute la codebase pour TODO, FIXME, HACK et XXX, et récupère les issues GitHub ouvertes via le CLI gh. Pour chaque élément important, elle lance un court Q&A : quel est le problème, y a-t-il une solution claire, quelle est l'estimation d'effort, y a-t-il des bloqueurs ? Tout est trié en trois catégories — critique, important, backlog — et un bloc ## Next Session est écrit dans CLAUDE.md avec les priorités du lendemain classées par ordre.

Phase 4 — Préparation du commit. Stage les changements et compose un message de commit conventionnel. S'il existe des issues critiques non résolues, elle se met en pause et affiche le diff stagé pour revue. Sinon, elle procède automatiquement.

Phase 5 — Commit et push. Commit, push vers la branche de tracking courante, et affiche un résumé tenant sur un écran : ce qui a été livré, ce qui est critique pour demain, quels documents ont été mis à jour, et le hash du commit.

Qu'est-ce qu'une skill Claude Code, exactement ?

Claude Code dispose d'instructions persistantes et réutilisables qui étendent ses capacités. CLAUDE.md gère le contexte projet permanent. Les skills gèrent des workflows répétables spécifiques que vous invoquez à la demande.

Une skill est un répertoire contenant un fichier SKILL.md. Ce fichier a deux parties :

---
name: wrapup
description: End-of-day review, triage, and commit. Run before closing the project.
allowed-tools: Read, Write, Bash(git:*), Bash(gh:*), Bash(grep:*), Bash(npm:*), Bash(ruff:*), Bash(tsc:*)
---

# End-of-Day Wrapup

## Phase 1 — Review changes
Run `git status`, `git diff HEAD`, and `git log --oneline -10`.
Summarise what changed today in plain language.

## Phase 2 — Quality checks
Detect the toolchain from package.json or CLAUDE.md.
Run lint, type checks, tests, and build. Fix minor issues automatically.
Flag larger issues as TODOs rather than attempting repairs mid-wrapup.

## Phase 3 — Update memory and docs
...

Le frontmatter YAML indique à Claude Code le nom de la skill (qui devient la /slash-command), une description utilisée pour décider quand la charger automatiquement, et quels outils elle peut utiliser. Le corps Markdown est le prompt — en langage naturel, structuré comme bon vous semble pour la tâche.

Quand vous tapez /wrapup, Claude Code charge la skill dans le contexte et suit les instructions. Il peut exécuter des commandes bash, lire et écrire des fichiers, appeler le CLI gh, commiter dans Git — tout ce que la liste allowed-tools autorise.

Les skills font partie du standard ouvert Agent Skills, elles fonctionnent donc dans Claude Code, Claude sur le web et Claude Desktop. Définissez une fois, utilisez partout.

Trois façons d'installer une skill

Globale (disponible dans tous les projets)

Idéale quand la skill est généraliste et que vous la voulez quel que soit le dépôt dans lequel vous travaillez. /wrapup entre dans cette catégorie.

mkdir -p ~/.claude/skills/wrapup
nano ~/.claude/skills/wrapup/SKILL.md

Collez le contenu de la skill, enregistrez. Aucun redémarrage nécessaire — Claude Code détecte les changements de skills en temps réel.

Scopée au projet (commitée dans le dépôt)

Idéale quand la skill est spécifique au projet, ou quand toute l'équipe doit en disposer.

mkdir -p .claude/skills/wrapup
nano .claude/skills/wrapup/SKILL.md

Puis commitez-la :

git add .claude/skills/wrapup/SKILL.md
git commit -m "chore: add /wrapup end-of-day skill"
git push

Toute personne qui clone le dépôt obtient la skill automatiquement.

Override personnel au projet (non commité)

Pour les skills spécifiques au projet qui n'ont pas leur place dans la codebase partagée — styles de messages de commit opiniâtres, critères de triage personnels, raccourcis liés à votre stack que votre équipe n'utilise pas.

mkdir -p .claude/commands
echo ".claude/commands/" >> .gitignore
nano .claude/commands/wrapup.md

Invocation de la skill

Tapez / dans Claude Code et wrapup apparaît dans la liste d'autocomplétion :

/wrapup

Ou avec le préfixe du namespace projet en cas de conflit de nommage :

/project:wrapup

Vous pouvez vérifier qu'elle est bien enregistrée en exécutant /help — toutes les skills disponibles s'affichent avec leurs descriptions. Si wrapup est absente, vérifiez le chemin du SKILL.md et validez le frontmatter YAML.

Pourquoi le commit se met en pause sur les issues critiques

Une décision de conception qui mérite d'être expliquée : la skill commit et push automatiquement pour le travail normal, mais se met en pause si des issues critiques non résolues existent.

La logique dans les instructions de la skill :

## Phase 4 — Prepare the commit

Stage all changes with `git add -A`.
Compose a conventional commit message summarising today's work.

If any CRITICAL issues remain unresolved:
  - Print the staged diff
  - Print the proposed commit message
  - Wait for explicit confirmation before proceeding

Otherwise:
  - Commit and push without interruption

La pause n'est pas là pour vous empêcher de livrer. Elle sert à vous assurer que vous décidez consciemment de pousser dans un état où quelque chose d'important est cassé. Souvent vous pousserez quand même — le travail n'a rien à voir avec l'issue critique — mais vous le ferez intentionnellement plutôt qu'accidentellement.

Un outil automatisé qui livre silencieusement du code cassé est pire que pas d'automatisation du tout. La pause est la reconnaissance par la skill qu'elle n'a pas le contexte complet, et elle vous rend cette décision spécifique.

CLAUDE.md comme mémoire de travail

Le bloc ## Next Session écrit à la fin de la Phase 3b mérite sa propre section.

Parce que Claude Code charge CLAUDE.md automatiquement au début de chaque session, demain matin Claude connaît déjà les trois choses à faire, par ordre de priorité. Vous n'avez pas besoin de ré-expliquer le contexte, de relire vos propres notes, ou de passer quinze minutes à vous souvenir d'où vous en étiez.

Le bloc ressemble à ceci après un wrapup typique :

## Next Session

**Last updated:** 2025-01-14 18:03

### Critical
- [ ] Fix auth token expiry not being caught in `api/middleware.ts` — users hitting 401s silently
- [ ] The `/export` endpoint times out for datasets > 10k rows — needs investigation

### Important
- [ ] Migrate remaining fetch calls in `dashboard/` to the new API client
- [ ] Write tests for the CSV parser edge cases (empty rows, quoted commas)

### Backlog
- [ ] Update the deployment docs — still references the old Docker setup
- [ ] TODO in `utils/date.ts:47` — handle timezone offsets properly

Chaque session se termine en passant le relais à la suivante. Au fil du temps, CLAUDE.md devient un document vivant qui reflète l'état actuel du projet — pas seulement l'architecture, mais le travail en cours. Quand vous intégrez un nouveau collaborateur, ou revenez sur un projet après deux semaines, ce fichier raconte toute l'histoire.

À quoi ressemble la sortie

Après l'exécution de /wrapup, le résumé final s'affiche dans le terminal :

── Wrapup complete ──────────────────────────────────────

Commit: a3f91c2
Branch: main → origin/main

Changed
  Modified  src/api/middleware.ts
  Modified  src/dashboard/index.tsx
  Added     src/utils/csv-parser.ts
  Modified  README.md

Quality checks
  ESLint      passed
  TypeScript  passed
  Tests       47 passed, 0 failed
  Build       passed
  Fixed       2 stray console.log statements

Docs updated
  CLAUDE.md   Next Session block updated
  README.md   Updated /export endpoint docs

Critical for tomorrow
  1. Auth token expiry silent failure — api/middleware.ts
  2. /export timeout on large datasets

─────────────────────────────────────────────────────────

Un seul écran. Tout ce qu'il vous faut pour fermer le laptop.

Adaptez-la à vos besoins

La skill wrapup a pris environ une heure à écrire et fait partie de notre routine quotidienne depuis. L'historique Git est plus propre. La documentation est plus précise. Chaque matin démarre avec une liste claire déjà chargée dans le contexte.

C'est aussi un bon exemple de ce à quoi les skills servent en général : prendre un workflow multi-étapes, dépendant du contexte, que vous feriez autrement manuellement — ou que vous sauteriez — et l'encoder une fois dans un fichier Markdown. Claude Code gère l'exécution. Vous tapez un mot.

Le coût d'une bonne routine de fin de journée n'est pas le travail en lui-même. C'est la friction de se rappeler de le faire et de savoir par où commencer. Une skill élimine les deux. Copiez le fichier, remplacez npm test par pytest, remplacez ESLint par Ruff, ajoutez les contrôles spécifiques à votre projet — et lancez /wrapup ce soir.

Si vous rencontrez un problème en adaptant la skill à votre stack, collez l'URL de cet article dans Claude Code ou l'assistant IA de votre choix. Il aura tout le contexte nécessaire pour vous aider à déboguer.

Où exécuter tout cela

Vous avez besoin d'une machine où Claude Code et Git sont disponibles — c'est-à-dire n'importe quel serveur Linux avec un terminal. Si vous exécutez vos environnements de développement sur un VPS, Hetzner vous propose un CX22 à 4,85 €/mois avec 10 € de crédit offert. C'est ce sur quoi tourne ce blog.

Si vous préférez éviter la gestion de serveur et souhaitez un environnement hébergé pour vos workflows IA, xCloud gère l'infrastructure pour que vous puissiez vous concentrer sur les skills elles-mêmes.

Pour les équipes qui veulent du monitoring sur les services vers lesquels Claude commit, UptimeRobot couvre 50 moniteurs sur son offre gratuite avec des intervalles de 5 minutes — utile pour détecter ces problèmes de timeout sur /export avant vos utilisateurs.

(Liens affiliés — nous percevons une petite commission si vous vous inscrivez, sans aucun coût pour vous.)