C'est le 31 mars 2026. Tu t'es levé, tu as ouvert ton laptop et passé 30 minutes à lire les modifs de quelqu'un d'autre. Puis 20 minutes à écrire des tests que tu ne reliras jamais. Puis 15 minutes à rédiger un email qui dit ' comme évoqué précédemment ' de quatre manières polies différentes. Puis encore une heure à te battre avec un tableur pour qu'il daigne obéir.

Tu n'as rien fait d'utile, et c'est déjà la pause déj. 😼

Voici le calcul qui dérange : tu crames plus de 50 heures par mois sur des tâches qu'une IA gère pour environ 65 centimes. Pas avec un outil-miracle annoncé pour le trimestre prochain — avec des commandes que tu peux taper dans un terminal maintenant. Ce guide te donne les scripts exacts, les coûts et les limites. Copie, colle, récupère ton agenda.

Catégorie 1 : Tâches de code

Revue de code

L'ancienne méthode : Tu relis chaque PR — une pull request, c'est-à-dire les modifications de code proposées par quelqu'un — en cherchant les problèmes de style, les bugs, les failles de sécurité et les cas limites oubliés. Ça prend 15 à 60 minutes par PR, et au troisième tes yeux se vitrifient.

La nouvelle méthode :

claude "Review the diff in the last commit. Check for:
  1. Security vulnerabilities
  2. Performance issues
  3. Missing error handling
  4. Logic bugs
  5. Style inconsistencies
Report findings with severity (critical/warning/info)."

Ou branche-le dans ta CI — l'intégration continue, le système qui teste automatiquement ton code à chaque push. Voici un workflow GitHub Actions qui review chaque PR automatiquement :

name: AI Code Review
on: [pull_request]
jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Review with Claude
        run: |
          DIFF=$(git diff origin/main...HEAD)
          jq -n --arg diff "$DIFF" '{
            "model": "claude-haiku-4.5",
            "max_tokens": 2000,
            "messages": [{
              "role": "user",
              "content": ("Review this code diff for bugs, security issues, and style problems. Be concise.\n\n" + $diff)
            }]
          }' | curl -s -X POST https://api.anthropic.com/v1/messages \
            -H "x-api-key: ${{ secrets.ANTHROPIC_API_KEY }}" \
            -H "anthropic-version: 2023-06-01" \
            -H "content-type: application/json" \
            -d @- > review.json

Coût : ~0,002 $ par review avec Claude Haiku. Soit 0,06 $/mois à raison d'une PR par jour.

En vrai : Ça détecte environ 70 % de ce qu'un humain trouverait. Ça rate la compréhension de la logique métier et le goût architectural. Mais ça excelle sur les trucs chiants — les null checks, les race conditions, les failles de sécurité — précisément parce que ça ne s'ennuie jamais. 😸

Génération de tests

L'ancienne méthode : Tu écris les tests à la main, ou plus honnêtement, tu les zappes parce que c'est pénible. 30 à 60 minutes par module quand tu daignes t'y mettre.

La nouvelle méthode :

claude "Read src/auth/ and write comprehensive tests for the login flow.
Cover: happy path, wrong password, account locked, rate limiting,
SQL injection in email field, missing fields.
Use pytest. Mock the database. Output to tests/test_auth.py."

Coût : ~0,01 $ par module avec Sonnet. Les tests générés sont verbeux mais complets — ils testent des cas limites que tu aurais zappés parce que ' qui tape un email de 10 000 caractères ? ' Quelqu'un le fera.

Refactoring

L'ancienne méthode : Renommer une fonction dans 30 fichiers. Migrer d'un ORM — object-relational mapper, la couche entre ton code et ta base de données — vers un autre. Des heures, voire des jours.

La nouvelle méthode :

claude "Refactor the codebase to replace all direct SQL queries with
Supabase client calls. ~15 files using raw SQL.
For each file:
1. Replace the SQL query with the equivalent Supabase call
2. Update the imports
3. Update error handling to match Supabase patterns
4. Run the tests to verify"

Coût : 0,10–0,50 $ pour un refactoring conséquent. Claude Code lit tous les fichiers, comprend les patterns et applique les changements de manière cohérente. Review quand même le diff avant de commit — toujours. 😾

Catégorie 2 : Contenu et communication

Rédaction d'emails

L'ancienne méthode : Fixer l'écran vide. Écrire. Réécrire. Réécrire encore. 10 à 30 minutes par email important.

La nouvelle méthode : Un petit script Python utilisant l'API Anthropic — l'interface de programmation qui permet à ton code de parler à Claude :

import anthropic

client = anthropic.Anthropic()

def draft_email(context: str, tone: str = "professional") -> str:
    response = client.messages.create(
        model="claude-haiku-4.5",
        max_tokens=1000,
        messages=[{
            "role": "user",
            "content": f"""Draft an email based on this context:
{context}

Tone: {tone}
Rules:
- Get to the point in the first sentence
- No filler phrases ("I hope this email finds you well")
- Under 150 words
- Clear call to action at the end"""
        }]
    )
    return response.content[0].text

python email_drafter.py "Declining a meeting invite from VP of Marketing
about Q3 planning because I have a conflicting deadline. Suggest async
alternative. Tone: friendly but firm."

Coût : ~0,001 $ par email. Gratuit, en gros.

Documentation

L'ancienne méthode : Personne n'écrit de docs. Le README dit ' TODO. ' Il dit ' TODO ' depuis 2024.

La nouvelle méthode :

claude "Read every file in src/. Generate:
1. A README.md with project overview, setup instructions, and architecture
2. Inline docstrings for every public function missing one
3. An API.md documenting every endpoint in src/routes/

Be accurate — read the code, don't guess."

Coût : 0,05–0,20 $ selon la taille du code. La doc générée par l'IA est verbeuse mais fidèle. Elle décrit correctement ce que le code fait. Elle n'expliquera pas pourquoi le code existe — ça, c'est ton boulot. Mais ' précis et bavard ' bat ' inexistant ' tous les jours de la semaine.

Changelog et notes de version

git log --oneline v1.2.0..HEAD | claude "Convert these commits
into user-facing release notes. Group by: New Features, Bug Fixes,
Improvements. Ignore internal refactoring. Write for end users,
not developers."

Coût : ~0,001 $. Celui-là ne devrait même pas nécessiter une réflexion.

Catégorie 3 : Traitement de données

Nettoyage de CSV

L'ancienne méthode : Ouvrir Excel. Corriger le formatage. Supprimer les doublons. Standardiser les dates. 30 minutes à 2 heures de souffrance pure.

La nouvelle méthode :

import anthropic

client = anthropic.Anthropic()

def clean_csv(filepath: str, instructions: str) -> str:
    with open(filepath) as f:
        data = f.read()
    response = client.messages.create(
        model="claude-haiku-4.5",
        max_tokens=4096,
        messages=[{
            "role": "user",
            "content": f"""Clean this CSV data:
{instructions}

Data:
{data[:3000]}

Return the cleaned CSV. Maintain the header row."""
        }]
    )
    return response.content[0].text

python clean_csv.py contacts.csv "Standardize phone numbers to +33-X-XX-XX-XX-XX.
Remove duplicate emails (keep the row with more data).
Fix obvious city name typos. Convert dates to YYYY-MM-DD."

Coût : ~0,005 $ par fichier.

Rapports hebdomadaires

L'ancienne méthode : Requêter la base de données, exporter dans un tableur, faire des graphiques, rédiger un commentaire. 2 à 4 heures chaque semaine.

La nouvelle méthode :

import anthropic, subprocess
from datetime import datetime

client = anthropic.Anthropic()

data = subprocess.run(
    ["psql", "-c", "SELECT * FROM weekly_metrics", "--csv"],
    capture_output=True, text=True
).stdout

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=2000,
    messages=[{
        "role": "user",
        "content": f"""Generate a weekly business report from this data:
{data}

Include:
- Executive summary (3 sentences)
- Key metrics with week-over-week changes
- Notable trends or anomalies
- Recommended actions

Format as markdown."""
    }]
)

with open(f"reports/weekly-{datetime.now():%Y-%m-%d}.md", "w") as f:
    f.write(response.content[0].text)

Programme-le avec cron — un outil intégré qui exécute des scripts à intervalles réguliers :

# crontab -e
0 9 * * MON python3 /path/to/weekly_report.py

Coût : 0,02 $ par rapport. 0,08 $/mois pour un rythme hebdomadaire. 😸

Catégorie 4 : Administration système

Analyse de logs

L'ancienne méthode : grep -r "ERROR" /var/log/ puis fixer 200 lignes de stack traces en faisant semblant de comprendre le pattern. 30+ minutes.

La nouvelle méthode :

tail -200 /var/log/app/error.log | claude "Analyze these error logs.
Group by error type. Identify the root cause of the most frequent error.
Suggest a fix with code if possible."

Coût : ~0,003 $ par analyse.

Scripts de monitoring

claude "Write a bash script that:
1. Checks if nginx is running, restarts if not
2. Checks disk usage, alerts if > 80%
3. Checks SSL cert expiry, alerts if < 14 days
4. Checks main API endpoint responds with 200
5. Sends alerts to a Telegram bot
6. Runs every 5 minutes via cron

Use curl for HTTP checks. Use openssl for cert checks.
Include the cron line at the top as a comment."

Un script de monitoring fonctionnel en 30 secondes. Relis-le, teste-le, déploie-le. Coût : ~0,003 $, une seule fois, pour un script que tu utiliseras pendant des mois.

Catégorie 5 : Recherche et décisions

Évaluation technologique

L'ancienne méthode : 20 onglets ouverts, trois articles comparatifs de 2023, un thread Reddit qui dégénère en guerre de religion sur Rust. 2 à 4 heures par décision.

La nouvelle méthode :

claude "I need a message queue for a Python backend.
Requirements: ~10K messages/day, dead letter queue,
works with Supabase, team of 1.

Compare: Redis Streams, RabbitMQ, SQS, Supabase Queues.
For each: pricing at my scale, setup complexity,
Python SDK quality, gotchas. Give me a recommendation."

Coût : ~0,005 $ avec Sonnet. Une meilleure comparaison que 2 heures à jongler entre les onglets.

Attention : Vérifie toujours les prix de manière indépendante. L'IA peut être en retard sur les tarifs précis. Le cadre d'analyse est solide ; les montants en dollars méritent une vérification rapide. 😾

Le bilan des dégâts

Tâche Temps manuel Temps IA Coût IA/mois Heures économisées/mois
Revue de code (1/jour) 30 min 2 min 0,06 $ 9,3
Génération de tests (2/sem.) 45 min 5 min 0,08 $ 5,3
Rédaction d'emails (3/jour) 15 min 1 min 0,09 $ 14,0
Documentation 4 heures 15 min 0,20 $ 3,75
Changelog (2/mois) 30 min 2 min 0,002 $ 0,9
Nettoyage CSV (2/sem.) 30 min 3 min 0,04 $ 3,6
Rapport hebdomadaire 2 heures 5 min 0,08 $ 7,7
Analyse de logs (quotidien) 15 min 2 min 0,09 $ 6,5
Total ~0,65 $ ~51 heures

Soixante-cinq centimes. Cinquante et une heures. Six jours de travail récupérés chaque mois. Ce n'est pas une faute de frappe.

Ce qu'il ne faut PAS automatiser (pour l'instant)

Certaines choses que l'IA fait encore mal en mars 2026 :

  • Tout ce qui demande de l'empathie réelle — emails d'excuse aux clients, conversations de licenciement, sujets RH sensibles. L'IA peut rédiger un brouillon ; un humain doit relire et envoyer.
  • Décisions stratégiques — L'IA peut analyser les données et présenter les options, mais ' est-ce qu'on pivote ? ' reste ton problème.
  • Documents juridiques — L'IA peut rédiger, mais ne publie jamais un texte juridique sans l'aval d'un avocat.
  • Travail créatif de marque — L'IA génère des options, mais la voix de marque et la direction créative nécessitent du goût humain.
  • Code critique pour la sécurité — L'IA peut l'écrire, mais les chemins critiques en sécurité exigent un humain qui comprend le modèle de menace.

Le schéma : l'IA gère les 80 % qui sont répétitifs et structurés. Les 20 % qui nécessitent du jugement, de l'empathie ou de la responsabilité restent les tiens. Automatise les 80 %, concentre ton énergie sur les 20 % qui comptent vraiment.

Maintenant, passe à l'action

Tu te souviens de cette matinée du début ? Celle où tu as brûlé la moitié de ta journée en tâches de robot ? Cette matinée est optionnelle. 😹

Le plus gros obstacle n'est pas technique — chaque script ci-dessus fonctionne aujourd'hui. C'est psychologique. ' Je devrais le faire moi-même ' semble responsable. Mais passer une heure à formater un CSV n'est pas responsable — c'est de l'évitement. Tu te planques dans le travail ingrat au lieu de faire les trucs difficiles que toi seul peux faire : parler aux clients, prendre des décisions produit, closer des deals.

Choisis une automatisation de ce guide. Une seule. Mets-la en place cette semaine. Ressens ce que ça change dans ta journée. Puis automatise le truc suivant. D'ici la fin du mois, tu te demanderas pourquoi tu as jamais fait tout ça à la main — et tu auras 51 heures de preuve que tu as eu raison d'arrêter. 😼