Maîtriser l'IA en 30 jours : La feuille de route complète

La plupart des gens utilisent l'IA depuis deux ans et tapent encore dans la boîte comme s'ils cherchaient sur Google. Une ligne vague, un haussement d'épaules devant la réponse, fermer l'onglet. Ils « utilisent l'IA » comme on « utilise » un tapis de course sur lequel on suspend des chemises.

Voici la partie inconfortable : l'écart entre ceux qui tirent 10x de ces modèles et ceux qui n'en tirent rien n'est ni le talent, ni un modèle secret. C'est un système. Les 10x réutilisent les mêmes quelques gestes – chaque invite, chaque jour – jusqu'à ce que les gestes deviennent une mémoire musculaire.

La maîtrise n'est pas de connaître plus d'invites. C'est de posséder un système reproductible que vous exécutez sans réfléchir.

Voici ce système, condensé en 30 jours. Quatre semaines, douze jeux numérotés, chacun se terminant par une chose que vous faites aujourd'hui. Des invites copiables. Du Python réel et exécutable (vérifié avec le SDK d'Anthropic, v0.109.1). Aucune théorie que vous ne puissiez mettre en pratique d'ici ce soir.

Le coup d'envoi culturel a été la désormais célèbre phrase d'Andrej Karpathy sur le « vibe coding » – « vous vous abandonnez complètement aux vibes... et oubliez que le code existe même. » C'est la vibe. Voici la discipline en dessous qui permet à la vibe de vraiment aboutir.

Partie 1 · Semaine 1 – Le modèle mental et les premières victoires (Jours 1–7)

L'objectif de cette semaine n'est pas la connaissance. C'est une victoire. D'ici le jour 7, vous devriez avoir délégué au moins une tâche réelle à un modèle et ressenti le temps vous revenir. Tout le reste repose sur ce sentiment.

01. Livrez une tâche réelle avec l'IA – aujourd'hui.

Ne commencez pas par un cours. Commencez par une corvée que vous devez déjà à quelqu'un : un email que vous redoutez, des notes à nettoyer, une fonction à rédiger. Le moyen le plus rapide de « comprendre » l'IA est de lui confier quelque chose avec de vrais enjeux et de juger le résultat par rapport à ce que vous auriez écrit vous-même.

L'erreur des débutants est de taper un sujet (« écrire sur l'intégration ») au lieu d'un brief. Traitez le modèle comme une nouvelle recrue brillante le premier jour : il a les compétences mais aucun de votre contexte. Donnez-lui un rôle, la tâche, le contexte et le résultat exact que vous voulez.

Utilisez-le quand : vous avez une tâche que vous feriez normalement seul en moins d'une heure – écrire, résumer, reformater, réfléchir, planifier.

1Vous êtes mon <rôle, par ex. "rédacteur en chef direct">.
2Tâche : <une tâche concrète en une phrase>.
3Contexte : <2–3 lignes que le modèle ne peut pas connaître – public, objectif, contraintes>.
4Résultat : <format exact – longueur, structure, ton>.
5Si quelque chose est ambigu, demandez-moi d'abord au lieu de deviner.

Cette dernière ligne est l'astuce secrète. Elle transforme une tentative unique en une courte conversation, et les conversations battent les monologues presque à chaque fois.

Faites-le maintenant : choisissez une tâche sur votre liste, remplissez les quatre emplacements, exécutez-la. Gardez l'invite – vous réutiliserez le squelette tout le mois.

02. Apprenez l'anatomie d'une invite qui fonctionne.

Chaque invite fiable a trois parties, et les débutants en sautent deux. Clarté (dites exactement ce que vous voulez), contexte (dites pourquoi et pour qui), et format (dites à quoi le résultat doit ressembler). Les propres conseils d'Anthropic appellent cela la règle de la « nouvelle recrue brillante » : plus vous expliquez précisément, meilleur est le résultat – et leur règle d'or littérale est « montrez votre invite à un collègue avec un contexte minimal ; s'il est confus, le modèle le sera aussi. »

L'amélioration la plus efficace est d'ajouter la motivation. Ne dites pas simplement « n'utilisez jamais de points de suspension ». Dites « ceci sera lu à haute voix par un moteur de synthèse vocale, donc n'utilisez jamais de points de suspension – il ne peut pas les prononcer. » Le modèle généralise à partir de la raison. C'est la différence entre un ordre et une explication.

Utilisez-le quand : une réponse revient générique, hors ton, ou techniquement correcte mais inutile. Neuf fois sur dix, l'une des trois parties manquait.

1# Faible (sujet, pas un brief)
2Écrire sur notre nouvelle fonctionnalité.
3
4# Fort (clarté + contexte + format)
5Rédigez une annonce produit de 120 mots pour notre nouveau « Mode Focus ».
6Public : utilisateurs existants qui trouvent l'application bruyante.
7Objectif : les inciter à l'essayer une fois cette semaine.
8Ton : calme, confiant, zéro hype.
9Format : 1 court paragraphe + un CTA d'une ligne.

Faites-le maintenant : prenez l'invite faible d'hier et réécrivez-la avec les trois parties étiquetées. Exécutez les deux. Regardez l'écart.

03. Volez les 6 techniques de base – et une ligne de code.

Ces six apparaissent dans tous les guides sérieux d'ingénierie de prompts parce qu'elles continuent de fonctionner : (1) soyez clair et direct, (2) ajoutez du contexte/de la motivation, (3) donnez des exemples, (4) structurez avec des balises de type XML, (5) attribuez un rôle, (6) dites-lui de réfléchir avant de répondre. Vous passerez la semaine 2 à approfondir chacune – voici la carte.

Deux méritent d'être câblées immédiatement : les rôles et les balises. Un rôle dans l'instruction système oriente le ton et le jugement pour toute la conversation ; même une phrase fait bouger l'aiguille. Les balises comme <context> et <examples> empêchent le modèle de confondre vos instructions avec vos données. Voici la technique du rôle sous forme de code réel et exécutable – votre premier aperçu de l'API que vous habiterez d'ici la semaine 3.

Utilisez-le quand : vous voulez un comportement cohérent sur plusieurs appels (le rôle) ou vous mélangez des instructions avec des entrées désordonnées (les balises).

1import anthropic
2
3client = anthropic.Anthropic()  # lit ANTHROPIC_API_KEY dans votre environnement
4
5msg = client.messages.create(
6    model="claude-opus-4-8",
7    max_tokens=1024,
8    system="Vous êtes un réviseur de copie senior. Vous coupez le superflu et gardez la voix de l'auteur.",  # le rôle
9    messages=[
10        {"role": "user", "content": "Modifiez ce paragraphe, puis listez ce que vous avez changé :\n\n<draft>...</draft>"}
11    ],
12)
13print(msg.content[0].text)

Faites-le maintenant : réécrivez une invite avec un rôle explicite et des <balises> autour de l'entrée. Vous avez maintenant utilisé 2 des 6 – la semaine 2 termine l'ensemble.

Partie 2 · Semaine 2 – Ingénierie de prompts pour des résultats réels (Jours 8–14)

Cette semaine, vous transformez « ça marche à peu près » en « ça marche à tous les coups ». Même tâche, même forme, même qualité – à la demande. Cette fiabilité est ce qui vous permet d'automatiser à la semaine 3.

04. Verrouillez le ton et le format avec des exemples multi-shot.

Dire au modèle ce que vous voulez est bien. Montrer est mieux. Quelques exemples bien choisis (la technique s'appelle few-shot ou multishot) verrouillent le format, le ton et les cas limites de manière plus fiable que n'importe quel adjectif. Les conseils sont cohérents dans tout le domaine : incluez 3 à 5 exemples, variez-les pour que le modèle ne s'accroche pas à un motif accidentel, et encadrez chacun avec des balises pour qu'il soit clairement un exemple et non une instruction.

C'est le plus grand bond de qualité pour le travail répétitif – classification, extraction, formatage, réécriture. Si vous faites le même type de tâche plus de deux fois par semaine, cela mérite des exemples.

Utilisez-le quand : le format de sortie varie entre les exécutions, ou vous avez besoin que le modèle corresponde à un style maison spécifique.

1Classifiez chaque ticket de support comme exactement l'un de : bug | facturation | fonctionnalité.
2
3<exemples>
4<exemple>
5Ticket : "J'ai été facturé deux fois ce mois-ci."
6Catégorie : facturation
7</exemple>
8<exemple>
9Ticket : "Le bouton d'exportation ne fait rien sur Safari."
10Catégorie : bug
11</exemple>
12<exemple>
13Ticket : "Veuillez ajouter un mode sombre."
14Catégorie : fonctionnalité
15</exemple>
16</exemples>
17
18Ticket : "L'application plante quand je télécharge un PDF."
19Catégorie :

Faites-le maintenant : prenez une tâche récurrente, écrivez 3 exemples variés dans des balises <exemple>, et regardez la sortie se mettre en forme.

05. Faites réfléchir le modèle avant de répondre.

Pour tout ce qui implique du raisonnement – analyse, mathématiques, planification, jugement délicat – la pire chose à faire est d'exiger la réponse immédiatement. Donnez-lui de l'espace pour raisonner d'abord. Vous pouvez soit laisser les modèles plus récents réfléchir de manière adaptative, soit, en chat simple, le forcer : demandez un raisonnement étape par étape dans un bloc <thinking>, puis une réponse finale concise dans un bloc <answer>. Séparer les deux signifie que vous bénéficiez du raisonnement sans le mur de texte.

Un geste bonus issu des conseils d'Anthropic : demandez-lui de s'auto-vérifier avant de terminer – « vérifiez votre réponse par rapport aux contraintes ci-dessus. » Il attrape ses propres erreurs étonnamment souvent, surtout en mathématiques et logique.

Utilisez-le quand : la tâche comporte plus d'une étape, une réponse correcte sur laquelle vous pouvez vous tromper, ou des compromis à peser.

1Question : <une question avec un vrai compromis>
2
3D'abord, raisonnez à l'intérieur des balises <thinking> : listez ce que vous savez, ce qui manque,
4et deux réponses candidates avec leurs compromis.
5Puis donnez votre décision à l'intérieur des balises <answer> – 3 phrases maximum.
6Avant de terminer, vérifiez que votre réponse ne contredit rien de ce qui précède.

Faites-le maintenant : prenez une décision que vous pesez, exécutez-la via la séparation réflexion/réponse, et lisez le <thinking> – c'est là que se cache la valeur.

06. Construisez une bibliothèque d'invites réutilisables.

Maintenant, vous avez écrit une douzaine de bonnes invites et en avez perdu la moitié dans l'historique des discussions. Arrêtez. Les pros ne réécrivent pas les invites – ils remplissent des modèles. Rassemblez vos meilleures invites dans un seul fichier avec des {variables} pour les parties qui changent, et vous aurez transformé une astuce ponctuelle en infrastructure.

C'est le pivot des 30 jours : c'est le moment où vos invites cessent d'être jetables et commencent à composer. Un simple dict Python et str.format est tout ce dont vous avez besoin pour commencer – aucun framework, aucune dépendance.

Utilisez-le quand : vous avez exécuté une invite similaire trois fois. La troisième fois, transformez-la en modèle.

1# prompt_library.py — vos invites comme infrastructure réutilisable
2TEMPLATES = {
3    "summarize": (
4        "Vous êtes un {role}.\n"
5        "Résumez le texte ci-dessous pour {audience}.\n"
6        "Format : {fmt}.\n\n"
7        "<text>\n{text}\n</text>"
8    ),
9}
10
11def build(name: str, **kwargs) -> str:
12    return TEMPLATES[name].format(**kwargs)
13
14prompt = build(
15    "summarize",
16    role="rédacteur technique",
17    audience="utilisateurs non techniques",
18    fmt="3 points, max 15 mots chacun",
19    text="...collez les notes de version ici...",
20)
21print(prompt)  # transmettez ceci directement dans client.messages.create(...)

Faites-le maintenant : créez prompt_library.py, déplacez vos 3 meilleures invites dans des modèles avec variables. Ce fichier grandit tout le mois.

Partie 3 · Semaine 3 – Automatisation avec l'API (Jours 15–21)

Le chat est l'endroit où vous apprenez. L'API est l'endroit où vous passez à l'échelle. Cette semaine, vous passez de l'exécution de tâches une par une à leur exécution par centaines, selon un calendrier, pendant que vous dormez.

07. Passez du chat à l'API.

L'API n'est que vos invites de chat dans une fonction que vous pouvez appeler. Si vous pouvez écrire une invite, vous pouvez écrire ceci – c'est dix lignes. Définissez votre clé comme variable d'environnement (ne la collez jamais dans le code), encapsulez l'appel dans une fonction, et vous avez une commande IA réutilisable que vous pouvez intégrer dans n'importe quel script.

Simon Willison, qui a documenté l'utilisation pratique des LLM mieux que presque personne, souligne que le levier ne réside pas dans des configurations exotiques – il réside dans le fait de câbler les modèles dans les petits outils que vous utilisez déjà. Cette fonction est ce fil.

Utilisez-le quand : vous voulez la même invite disponible partout – dans les scripts, les tâches cron, d'autres programmes – pas seulement dans un onglet de navigateur.

1import os
2import anthropic
3
4client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
5
6def ask(prompt: str) -> str:
7    msg = client.messages.create(
8        model="claude-opus-4-8",
9        max_tokens=1024,
10        messages=[{"role": "user", "content": prompt}],
11    )
12    return msg.content[0].text
13
14if __name__ == "__main__":
15    print(ask("Donnez-moi 5 lignes d'objet percutantes pour un email de lancement produit."))

Faites-le maintenant : installez le SDK (pip install anthropic), définissez ANTHROPIC_API_KEY, et exécutez ce fichier. Premier appel API réussi = Semaine 3 déverrouillée.

08. Transformez une corvée quotidienne en script.

C'est là que le temps revient vraiment. Toute tâche que vous effectuez sur un dossier de choses – résumer ces 50 transcriptions, étiqueter ces 200 tickets, réécrire ces 30 descriptions de produits – est une boucle. Écrivez la version pour un élément une fois, pointez-la vers un dossier, partez. Utilisez un modèle moins cher et plus rapide pour le travail en masse ; vous n'avez pas besoin de votre modèle le plus puissant pour résumer un mémo.

Utilisez-le quand : vous vous surprenez à faire la même tâche IA encore et encore à la main. Cette répétition est un script que vous n'avez pas encore écrit.

1import pathlib
2import anthropic
3
4client = anthropic.Anthropic()
5INBOX = pathlib.Path("./inbox")        # déposez les fichiers .txt ici
6OUT = pathlib.Path("./summaries")
7OUT.mkdir(exist_ok=True)
8
9def summarize(text: str) -> str:
10    msg = client.messages.create(
11        model="claude-haiku-4-5",      # pas cher + rapide : bon outil pour le travail en masse
12        max_tokens=300,
13        system="Résumez en 3 points concrets. Pas de superflu.",
14        messages=[{"role": "user", "content": text}],
15    )
16    return msg.content[0].text
17
18for f in INBOX.glob("*.txt"):
19    (OUT / f"{f.stem}.md").write_text(summarize(f.read_text(encoding="utf-8")), encoding="utf-8")
20    print("résumé :", f.name)

Faites-le maintenant : trouvez une corvée en lot, déposez les fichiers dans ./inbox, exécutez la boucle. Vous venez de faire une heure de travail en une minute.

09. Réduisez le coût et la latence avec la mise en cache.

Une fois que vous exécutez un volume réel, deux choses commencent à compter : la vitesse et la facture. Le plus grand levier est la mise en cache des invites. Si chaque appel partage un préfixe long et immuable – un guide de style, une base de connaissances, une grande instruction système – vous payez pour le relire à chaque fois. Marquez-le avec cache_control et le modèle réutilise la version mise en cache : une lecture de cache coûte environ 10 % du prix d'entrée normal, contre un écrit unique à +25 %. Pour les travaux en lot qui partagent un préfixe, l'API Batch ajoute une réduction supplémentaire d'environ 50 %.

Utilisez-le quand : de nombreux appels partagent un morceau de contexte statique volumineux (le cas classique : une longue instruction système réutilisée pour tout un travail).

1import anthropic
2
3client = anthropic.Anthropic()
4STYLE_GUIDE = open("style_guide.md").read()   # long, identique à chaque appel
5
6msg = client.messages.create(
7    model="claude-opus-4-8",
8    max_tokens=1024,
9    system=[
10        {
11            "type": "text",
12            "text": STYLE_GUIDE,
13            "cache_control": {"type": "ephemeral"},  # mettez en cache ce gros préfixe
14        }
15    ],
16    messages=[{"role": "user", "content": "Réécrivez cet email pour correspondre au guide :\n\n..."}],
17)
18print(msg.usage)  # regardez cache_read_input_tokens grimper après le premier appel

Faites-le maintenant : trouvez une invite avec un gros préfixe répété, encapsulez-la dans un bloc cache_control, et exécutez-la deux fois. Affichez msg.usage et regardez la lecture en cache s'activer.

Partie 4 · Semaine 4 – Outils, données et mise en production (Jours 22–30)

La dernière semaine est le saut de « l'IA qui parle » à « l'IA qui agit ». Vous donnez au modèle des outils, le connectez à vos données réelles, et conditionnez le tout en un flux de travail que vous utiliserez pendant des années.

10. Donnez des outils au modèle (appel de fonctions).

Un modèle seul ne peut que produire du texte. Donnez-lui des outils et il peut agir – consulter votre calendrier, interroger une API, effectuer un calcul. Vous décrivez chaque outil avec un nom, une description et un schéma JSON de ses entrées ; le modèle décide quand l'appeler et vous transmet des arguments structurés à exécuter. C'est le fondement de tous les « agents IA » dont vous avez entendu parler.

Utilisez-le quand : la tâche nécessite des données en direct ou une action que le modèle ne peut pas effectuer à partir du seul texte (tout ce qui contient « consulter », « récupérer », « calculer » ou « envoyer »).

1import anthropic
2
3client = anthropic.Anthropic()
4
5tools = [
6    {
7        "name": "get_calendar_events",
8        "description": "Renvoie les événements de l'utilisateur pour une date donnée.",
9        "input_schema": {
10            "type": "object",
11            "properties": {
12                "date": {"type": "string", "description": "Date au format AAAA-MM-JJ"}
13            },
14            "required": ["date"],
15        },
16    }
17]
18
19msg = client.messages.create(
20    model="claude-opus-4-8",
21    max_tokens=1024,
22    tools=tools,
23    messages=[{"role": "user", "content": "Qu'y a-t-il sur mon calendrier lundi prochain ?"}],
24)
25
26for block in msg.content:
27    if block.type == "tool_use":
28        print("Le modèle veut appeler :", block.name, "avec", block.input)
29        # maintenant, VOUS exécutez get_calendar_events(**block.input) et renvoyez le résultat

Faites-le maintenant : définissez un outil pour quelque chose que vous utilisez réellement (calendrier, météo, une recherche), et regardez le modèle produire un appel tool_use propre. Vous n'avez même pas besoin de l'exécuter encore – voyez simplement la décision.

11. Connectez l'IA à vos données avec MCP.

Coller du contexte manuellement ne passe pas à l'échelle. Le Model Context Protocol (MCP), introduit par Anthropic en novembre 2024, est la solution standard – considérez-le comme un port USB-C pour l'IA : une spécification de connecteur, et toute application conforme peut se brancher sur vos fichiers, bases de données et outils. Il est passé d'une idée interne à la norme de l'industrie en quelques mois, avec des milliers de serveurs prêts à l'emploi que vous pouvez intégrer via la configuration.

Vous n'écrivez pas de code pour utiliser la plupart des serveurs – vous ajoutez une entrée à un fichier de configuration. Voici un serveur de système de fichiers donnant à un modèle un accès en lecture à un dossier de notes :

Utilisez-le quand : vous alimentez constamment le modèle avec la même source de vérité à la main – vos docs, un dépôt, une base de données, une base de connaissances.

1{
2  "mcpServers": {
3    "filesystem": {
4      "command": "npx",
5      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/vous/notes"]
6    }
7  }
8}

Faites-le maintenant : parcourez les serveurs MCP disponibles, choisissez-en un qui pointe vers des données que vous utilisez chaque semaine, et ajoutez-le à la configuration de votre client. Posez une question à laquelle seules vos données peuvent répondre.

12. Conditionnez un flux de travail que vous réutiliserez pour toujours.

Jour 30. Vous avez des invites, des scripts et des outils – faites-en maintenant une chose que vous invoquez par son nom. Les compétences d'agent d'Anthropic (devenues un standard ouvert en décembre 2025) sont le format propre pour cela : un dossier avec un SKILL.md qui contient un nom, une description du moment où l'utiliser, et les étapes. Le modèle le charge uniquement lorsque c'est pertinent (un principe de conception appelé divulgation progressive), afin que vous puissiez en empiler des dizaines sans alourdir le contexte. Même si vous ne touchez plus jamais à l'API, écrire vos tâches répétables sous forme de compétences est l'habitude qui vous rendra rapide.

Utilisez-le quand : vous avez une tâche en plusieurs étapes que vous répéterez pendant des mois – un rapport hebdomadaire, une révision standard, un pipeline de formatage.

1---
2name: rapport-hebdomadaire
3description: Transformez mes notes brutes en rapport hebdomadaire standard. À utiliser quand je colle des notes et demande « l'hebdo ».
4---
5
6# Rapport hebdomadaire
7
8## Étapes
91. Regroupez les notes en : Livré, En cours, Bloqué.
102. Rédigez 2–3 points par groupe, au passé, sans superflu.
113. Terminez par « Semaine prochaine » – exactement 3 priorités.
12
13## Format
14- Titre : « Hebdo — <date> »
15- Moins de 200 mots. Pas de hype.

Faites-le maintenant : choisissez votre tâche la plus répétée, écrivez-la sous forme de SKILL.md avec une description précise. Cette description est ce qui la déclenche au bon moment – consacrez-y un réel effort.

Erreurs typiques (et la correction)

1. Invites vagues. « Écrire sur X » fait deviner votre intention au modèle – et il devine la moyenne. Correction : donnez toujours un rôle + contexte + format. Vous êtes <rôle>. Tâche : <une phrase>. Résultat : <format exact>.

2. Sur-prompt avec urgence en MAJUSCULES. Les modèles plus récents suivent les instructions précisément et réagissent de manière excessive à « CRITIQUE !!! Vous DEVEZ. » Les propres conseils d'Anthropic : réduisez à une formulation normale comme « Utilisez cet outil quand… ». Correction : écrivez les instructions comme vous le feriez pour un adulte compétent, pas comme si vous criiez sur un chien.

3. Décrire au lieu de montrer. Les adjectifs (« rendez-le professionnel ») sont faibles ; les exemples sont forts. Correction : ajoutez 3 à 5 exemples variés dans des balises <exemple> et laissez le motif faire le travail.

4. Formuler comme « ne pas ». « Ne soyez pas verbeux » fait penser le modèle à la verbosité. Correction : dites quoi faire – « Répondez en 2 phrases courtes. » Les instructions positives atterrissent plus fort que les interdictions.

5. Faire confiance à une sortie non vérifiée. Copier-coller une réponse non vérifiée est ainsi que les erreurs se propagent. Correction : pour un travail factuel, demandez-lui d'ancrer les affirmations dans des citations de la source et de s'auto-vérifier avant de terminer : Vérifiez chaque affirmation par rapport au texte ci-dessus ; signalez tout ce dont vous n'êtes pas sûr.

6. Faire à la main ce qu'une boucle pourrait faire. Exécuter la même invite 50 fois dans le chat est la chose la plus coûteuse que vous puissiez faire de votre après-midi. Correction : dès que vous rencontrez une répétition, écrivez la boucle du Bloc 08. Votre temps est la ressource rare, pas les jetons.

Conclusion : le système est la compétence

Trente jours ne font pas de vous un chercheur en IA. Cela vous rend quelque chose de plus utile : une personne avec un système. Vous pouvez prendre n'importe quelle tâche, lui donner un brief clair, lui montrer des exemples, la pousser à réfléchir, et – quand elle se répète – l'automatiser, la mettre en cache et la conditionner en une compétence que vous invoquez par son nom.

C'est tout le secret que le groupe des 10x n'a jamais caché. Pas plus d'invites. Pas un meilleur modèle. Un petit ensemble de gestes, exécutés jusqu'à devenir un réflexe. Vous avez maintenant les gestes. La seule variable qui reste est le nombre de répétitions.

Votre liste de contrôle des 30 jours – commencez aujourd'hui :

1. Livrez une tâche réelle avec une invite rôle + contexte + format (Bloc 01).
2. Créez prompt_library.py et déplacez vos 3 meilleures invites dans des modèles (Bloc 06).
3. Effectuez votre premier appel API avec la fonction ask() de 10 lignes (Bloc 07).
4. Automatisez une corvée en lot avec la boucle de dossier (Bloc 08).
5. Écrivez un SKILL.md pour votre flux de travail le plus répété (Bloc 12).

Faites ces cinq choses et vous dépassez 90 % de tous ceux qui « ont l'intention de se mettre à l'IA ». Ensuite, continuez simplement à exécuter la boucle.