Plannings — 4 parcours réalistes

Quatre façons de traverser les niveaux 00→10 (ROADMAP.md pour le détail des niveaux, docs/methode.md pour les routines de session). Les quatre parcours utilisent les mêmes leçons, les mêmes exercices, la même discipline Git — seule la vitesse change.

Conventions communes à tous les parcours :

Révisions : J+1 à chaque session (échauffement), J+7 chaque semaine, J+30 chaque mois — voir docs/methode.md sections 6–8. Elles sont comprises dans les horaires annoncés, pas en plus.
Commits/push : minimum réaliste indiqué par semaine. Un commit par série d'exercices, un par leçon terminée, un journal par session, push à chaque fin de session (GIT_WORKFLOW.md). Si tes chiffres sont très en dessous, tu ne commites pas assez souvent.
Critère de réussite : si le critère d'une semaine n'est pas atteint, on NE passe PAS à la semaine suivante — on prend 1 à 3 jours de rattrapage. Prendre du retard sur le planning est normal ; empiler des notions non acquises ne l'est pas.

Parcours 1 — Intensif : 4 semaines (2–3 h/jour, 6 j/7)

Pour qui : disponibilité réelle de 2–3 h par jour (congé, transition, temps plein sur le sujet). Routine : la « 2 heures » de docs/methode.md, avec pause obligatoire, éventuellement en deux blocs dans la journée (mieux qu'un seul).

Honnêteté d'abord. Quatre semaines couvrent solidement les niveaux 0→6 plus les projets du niveau 7. Les niveaux 8, 9 et 10 (tests, APIs, projet final) débordent sur des semaines 5 et 6 au même rythme — c'est écrit dans le planning ci-dessous, pas caché. Toute promesse « Python complet en 4 semaines » est un mensonge marketing ; ici le contrat est : en 4 semaines tu écris de vrais programmes en autonomie, et il reste 2 semaines pour le vernis professionnel.

Semaine 1 — Environnement + bases + logique (niveaux 0, 1, début 2)

Notions : niveau 0 en entier (jours 1–2 : Python, VS Code, terminal, Git/GitHub) ; niveau 1 en entier (jours 2–4 : print, variables, types, input, conversions, f-strings) ; niveau 2 entamé (jours 5–6 : if/elif/else, premiers while).
Exercices : toutes les séries des niveaux 0–1 (faciles + moyens + difficiles), séries « conditions » du niveau 2.
Mini-projets : ceux des leçons du niveau 1 + un mini-projet de synthèse (ex. convertisseur d'unités interactif).
Révisions : J+1 quotidienne dès le jour 2. Premier bilan hebdo au jour 7.
Commits/push attendus : ~15–20 commits, 6 push (un par jour travaillé).
Livrable : environnement opérationnel (python, git, repo poussé sur GitHub) + tous tes fichiers de réponses niveaux 0–1 dans mes-reponses/.
Critère de réussite : écrire de tête, sans regarder aucune leçon, un programme qui demande deux nombres à l'utilisateur et affiche leur somme, leur produit et lequel est le plus grand — et le committer proprement.

Semaine 2 — Boucles + structures de données (fin niveau 2, niveau 3)

Notions : fin du niveau 2 (jours 1–2 : for, range, break/continue, boucles imbriquées) ; niveau 3 en entier (jours 3–6 : listes, tuples, dicts, sets, mutabilité — la notion difficile de la semaine, la leçon le dit).
Exercices : toutes les séries des niveaux 2 et 3. Sur la mutabilité : faire AUSSI les variantes difficiles, c'est le point qui revient partout ensuite.
Mini-projets : jeu du nombre mystère (niveau 2) ; gestionnaire de liste (courses ou tâches, en mémoire) au niveau 3.
Révisions : J+1 quotidienne ; J+7 sur les leçons du niveau 1 ; bilan hebdo (refaire de tête 2 exercices ratés).
Commits/push attendus : ~15–20 commits, 6 push.
Livrable : le gestionnaire de tâches v1 (ajouter/lister/supprimer, tout en mémoire) commité en project:.
Critère de réussite : prédire correctement, par écrit avant exécution, la sortie d'un script qui modifie une liste passée entre deux variables (piège de mutabilité). Raté = refaire la leçon mutabilité avant la semaine 3.

Semaine 3 — Fonctions + fichiers/exceptions (niveau 4, début 5)

Notions : niveau 4 en entier (jours 1–4 : définition, paramètres, retour, scope — deuxième notion difficile du parcours — décomposition d'un problème) ; niveau 5 entamé (jours 5–6 : lecture/écriture de fichiers, chemins, try/except).
Exercices : toutes les séries du niveau 4 (y compris les difficiles : c'est ici que « penser comme un programmeur » se joue), séries fichiers + exceptions du niveau 5.
Mini-projets : refactoriser le gestionnaire de tâches en fonctions (aucune logique hors fonction sauf le point d'entrée) ; puis lui ajouter la sauvegarde dans un fichier.
Révisions : J+1 quotidienne ; J+7 sur niveaux 2–3 ; bilan hebdo.
Commits/push attendus : ~15 commits (dont des fix: de refactorisation), 6 push.
Livrable : gestionnaire de tâches v2 — découpé en fonctions, données persistées dans un fichier, entrées invalides gérées par try/except.
Critère de réussite : expliquer à voix haute la différence entre variable locale et globale avec un exemple écrit de tête, ET ton v2 survit à : fichier absent, saisie vide, saisie non numérique.

Semaine 4 — Modules + POO + projets (fin niveau 5, niveau 6, niveau 7)

Notions : fin du niveau 5 (jour 1 : imports, modules, organiser son code) ; niveau 6 en entier (jours 2–5 : classes, __init__, méthodes, encapsulation — 2 semaines prévues normalement, compressées ici : accepter que la POO continuera à mûrir pendant les projets) ; niveau 7 entamé (jour 6 : premier projet guidé).
Exercices : toutes les séries du niveau 6. Ne pas sauter les moyens pour « gagner du temps » — c'est la semaine où ce serait le plus tentant et le plus coûteux.
Mini-projets : gestionnaire de tâches v3 (une classe Task, une classe TaskManager) ; premier projet du niveau 7 démarré.
Révisions : J+1 quotidienne ; J+7 sur niveau 4 ; première révision J+30 sur les leçons de la semaine 1 ; bilan hebdo complet.
Commits/push attendus : ~15 commits, 6 push.
Livrable : v3 orienté objet qui fait exactement ce que faisait v2 (même comportement, meilleure structure) + projet niveau 7 en cours.
Critère de réussite : refaire de tête, fichier vierge, une classe avec __init__, deux attributs et deux méthodes, et l'utiliser — sans leçon ouverte. Et : bilan des 4 semaines écrit dans le journal.

Semaines 5–6 (le débordement assumé) — niveaux 7 (fin), 8, 9, 10

Au même rythme : semaine 5 = fin des projets du niveau 7 + niveau 8 (pytest, structure, refactoring) ; semaine 6 = niveau 9 (HTTP, JSON, CSV, automatisation) + démarrage du projet final niveau 10 (qui, lui, prend le temps qu'il prend — 2 à 4 semaines, c'est un projet, pas une leçon). Si tu dois t'arrêter à 4 semaines : tu as les niveaux 0–7, c'est déjà « je code en autonomie » ; reviens pour 8–10 dès que possible, en commençant par la routine de reprise (docs/methode.md section 11).

Parcours 2 — Équilibré : 8 semaines (1–1,5 h/jour, 5–6 j/7)

Pour qui : une heure fiable par jour à côté d'une activité principale. Routine : la « 1 heure » de docs/methode.md (les jours à 1,5 h : allonger le bloc exercices, pas le bloc leçon). Couvre les niveaux 0→10, avec un niveau 10 qui démarre en semaine 8 et se termine après (un projet final ne se boucle pas en quelques jours — voir la note en fin de parcours).

Semaine 1 — Niveaux 0 + 1

Notions : environnement complet (j1–2), puis toutes les leçons du niveau 1 (print, variables, types, input, conversions).
Exercices : toutes les séries niveaux 0–1.
Mini-projets : ceux des leçons du niveau 1.
Révisions : J+1 dès le jour 2 ; premier bilan hebdo en fin de semaine.
Commits/push : ~10–12 commits, 5–6 push.
Livrable : repo opérationnel poussé sur GitHub, réponses niveau 1 complètes.
Critère de réussite : programme « deux nombres → somme, produit, plus grand » écrit de tête et commité.

Semaine 2 — Niveau 2 (conditions, boucles, logique)

Notions : if/elif/else, while, for, range, break/continue, imbrication.
Exercices : toutes les séries du niveau 2, difficiles compris.
Mini-projets : jeu du nombre mystère (avec compteur d'essais).
Révisions : J+1 quotidienne, J+7 sur le niveau 1, bilan hebdo.
Commits/push : ~10 commits, 5–6 push.
Livrable : nombre mystère commité en project:.
Critère de réussite : écrire de tête une boucle qui affiche la table de multiplication de N en s'arrêtant proprement, + prédire sans exécuter la sortie de 3 exercices « prédiction » de la semaine.

Semaine 3 — Niveau 3 (structures de données)

Notions : listes, tuples, dicts, sets, mutabilité. Semaine chargée : si besoin, laisser les sets déborder sur la semaine 4 (jour 1), mais PAS la mutabilité.
Exercices : toutes les séries, insister sur mutabilité et dicts.
Mini-projets : gestionnaire de liste en mémoire (ajouter/lister/ supprimer/chercher).
Révisions : J+1, J+7 (niveau 2), bilan hebdo.
Commits/push : ~10 commits, 5–6 push.
Livrable : gestionnaire v1 commité.
Critère de réussite : le piège de mutabilité (liste partagée entre deux variables) prédit correctement par écrit ; savoir dire quand choisir liste vs dict et le justifier à voix haute.

Semaine 4 — Niveau 4 (fonctions)

Notions : définition, paramètres, valeurs de retour, scope, décomposition d'un problème en fonctions. Notion difficile de la semaine : le scope.
Exercices : toutes les séries. Les difficiles du niveau 4 sont le vrai test — y passer du temps.
Mini-projets : refactoriser le gestionnaire v1 en fonctions (v2).
Révisions : J+1, J+7 (niveau 3), J+30 sur la semaine 1 (routine mensuelle : refaire un mini-projet du niveau 1 de tête), bilan hebdo.
Commits/push : ~10 commits (dont fix: de refactorisation), 5–6 push.
Livrable : v2 en fonctions, même comportement que v1.
Critère de réussite : prendre un problème jamais vu (dans les exercices difficiles) et écrire la LISTE des fonctions avant tout code — puis les coder. Si tu codes d'abord et découpes après, refais un exercice de décomposition.

Semaine 5 — Niveau 5 + début niveau 6

Notions : fichiers, chemins, try/except, imports/modules (j1–4) ; premières leçons POO : classes, objets, __init__ (j5–6).
Exercices : toutes les séries du niveau 5, premières séries du 6.
Mini-projets : v3 du gestionnaire — persistance fichier + gestion des erreurs de saisie.
Révisions : J+1, J+7 (niveau 4), bilan hebdo.
Commits/push : ~10 commits, 5–6 push.
Livrable : v3 robuste (fichier absent, saisies invalides gérées).
Critère de réussite : ton programme ne crashe sur AUCUNE des saisies hostiles listées dans les exercices du niveau 5 ; premier __init__ écrit de tête.

Semaine 6 — Fin niveau 6 + niveau 7

Notions : méthodes, encapsulation, objets qui collaborent (j1–3) ; projets guidés du niveau 7 (j4–6).
Exercices : fin des séries du niveau 6.
Mini-projets : v4 orientée objet du gestionnaire ; premier projet guidé du niveau 7.
Révisions : J+1, J+7 (niveau 5), bilan hebdo.
Commits/push : ~10 commits, 5–6 push.
Livrable : v4 (classes Task + TaskManager) + projet 7 en cours.
Critère de réussite : classe complète écrite de tête (checklist niveau 6 cochée honnêtement) ; expliquer à voix haute ce que la POO a apporté à la v4 par rapport à la v3 — si la réponse est « rien », en discuter avec Claude avant de continuer.

Semaine 7 — Niveau 8 + début niveau 9

Notions : pytest, structure d'un projet, refactoring, docstrings (j1–4) ; HTTP et JSON (j5–6).
Exercices : écrire des tests pour ton gestionnaire v4 (c'est l'exercice principal du niveau 8) ; premières séries du niveau 9.
Mini-projets : v5 = v4 + tests + structure propre.
Révisions : J+1, J+7 (niveau 6), bilan hebdo.
Commits/push : ~10 commits, 5–6 push.
Livrable : pytest vert sur ton projet, structure de dossiers propre.
Critère de réussite : casser volontairement une fonction et voir un test échouer (si aucun test n'échoue, tes tests ne testent rien) ; premier appel HTTP qui parse du JSON réel.

Semaine 8 — Fin niveau 9 + démarrage niveau 10

Notions : CSV, automatisation de tâches réelles (j1–3) ; niveau 10 : choisir le projet final, écrire sa roadmap, démarrer (j4–6).
Exercices : fin des séries du niveau 9.
Mini-projets : un script d'automatisation qui te sert VRAIMENT (renommer des fichiers, agréger un CSV…).
Révisions : J+1, J+7 (niveaux 7–8), J+30 sur les semaines 4–5, bilan des 8 semaines dans le journal.
Commits/push : ~10 commits, 5–6 push.
Livrable : roadmap écrite du projet final + premier commit du projet.
Critère de réussite : la roadmap découpe le projet en étapes dont chacune produit quelque chose d'exécutable — pas « faire l'interface » mais « v0.1 : ajouter et lister depuis la ligne de commande ».

Note honnête sur le niveau 10 : le projet final prend 2 à 4 semaines de plus au même rythme. C'est voulu — c'est la partie « autonomie », elle n'a pas de date de fin fixée par un planning. Les 8 semaines t'amènent au point où tu peux le mener seul, avec le bilan hebdomadaire comme seul garde-fou.

Parcours 3 — Solide : 12 semaines (45 min–1 h/jour) ⭐ RECOMMANDÉ

C'est le parcours recommandé, et voici pourquoi : 45 min–1 h est un créneau tenable des mois sans épuisement (le vrai risque n'est pas d'aller lentement, c'est d'arrêter) ; les deux plateaux connus (niveaux 3–4, niveau 6) ont ici des semaines de consolidation dédiées au lieu d'être traversés en force ; et la révision espacée a le temps de faire effet — à ce rythme, chaque notion est revue trois fois avant d'être considérée acquise. Les parcours plus rapides couvrent autant, mais retiennent moins ; celui-ci est calibré pour que ce qui est vu reste. Routine : la « 1 heure » (ou « 30 minutes » les jours courts) de docs/methode.md.

Semaine 1 — Niveau 0

Notions : Python installé, VS Code, terminal, Git/GitHub — tout le niveau 0, sans se presser. Prendre le temps de comprendre Git (leçon 00-3 et GIT_WORKFLOW.md) : il sert tous les jours pendant 12 semaines.
Exercices : séries du niveau 0 (commandes terminal, cycle Git complet).
Mini-projets : premier script exécuté + premier push vérifié sur github.com.
Révisions : J+1 dès le jour 2.
Commits/push : ~8 commits, 5 push.
Livrable : environnement complet, repo poussé.
Critère de réussite : faire le cycle status→add→commit→push de tête, sans antisèche, avec un message de commit correct.

Semaine 2 — Niveau 1

Notions : print, variables, types, input, conversions, f-strings.
Exercices : toutes les séries du niveau 1.
Mini-projets : ceux des leçons + un convertisseur d'unités.
Révisions : J+1 quotidienne, J+7 (niveau 0 : re-répondre aux questions Git), premier bilan hebdo complet.
Commits/push : ~8–10 commits, 5 push.
Livrable : réponses niveau 1 complètes, convertisseur commité.
Critère de réussite : « deux nombres → somme, produit, plus grand » de tête ; expliquer la différence str/int/float à voix haute.

Semaine 3 — Niveau 2

Notions : if/elif/else, while, for, range, break/continue.
Exercices : toutes les séries du niveau 2.
Mini-projets : jeu du nombre mystère.
Révisions : J+1, J+7 (niveau 1), bilan hebdo.
Commits/push : ~8–10 commits, 5 push.
Livrable : nombre mystère avec compteur d'essais.
Critère de réussite : 3 prédictions de sortie sur 3 correctes sur les exercices « prédiction » ; une boucle while qui se termine toujours.

Semaine 4 — Niveau 3, première moitié

Notions : listes et tuples à fond, début des dicts. NE PAS courir : la mutabilité arrive en semaine 5, les fondations se posent ici.
Exercices : séries listes/tuples complètes, premières séries dicts.
Mini-projets : gestionnaire de liste v1 (listes seulement).
Révisions : J+1, J+7 (niveau 2), bilan hebdo.
Commits/push : ~8 commits, 5 push.
Livrable : v1 du gestionnaire.
Critère de réussite : manipuler une liste (ajouter, retirer, trier, parcourir) de tête, sans doc.

Semaine 5 — Niveau 3, fin + consolidation

Notions : dicts (fin), sets, mutabilité — LA notion difficile du premier plateau. Jours 5–6 : consolidation pure, aucune nouveauté.
Exercices : séries dicts/sets/mutabilité, PUIS refaire de tête les 3 exercices les plus durs des semaines 3–4.
Mini-projets : v1.5 — le gestionnaire passe des listes aux dicts là où c'est pertinent.
Révisions : J+1, J+7 (semaine 4), J+30 sur les semaines 1–2 (première routine mensuelle : refaire un mini-projet du niveau 1 de tête et comparer), bilan hebdo.
Commits/push : ~8–10 commits, 5 push.
Livrable : v1.5 + comparaison mensuelle notée dans le journal.
Critère de réussite : le piège de mutabilité prédit correctement par écrit, ET su l'expliquer à voix haute avec un dessin (deux noms → un objet).

Semaine 6 — Niveau 4

Notions : fonctions — définition, paramètres, retour, scope. C'est le cœur du plateau 3–4 : la semaine 7 continue dessus, pas de panique si tout n'est pas fluide vendredi.
Exercices : séries faciles + moyennes du niveau 4.
Mini-projets : commencer la refactorisation du gestionnaire en fonctions.
Révisions : J+1, J+7 (mutabilité — oui, encore), bilan hebdo.
Commits/push : ~8 commits, 5 push.
Livrable : premières fonctions extraites et commitées.
Critère de réussite : écrire de tête une fonction avec paramètres et valeur de retour, et expliquer pourquoi print dans la fonction ≠ return.

Semaine 7 — Niveau 4 fin + niveau 5 début

Notions : scope approfondi, décomposition d'un problème (j1–3) ; fichiers et chemins (j4–6).
Exercices : séries difficiles du niveau 4 (le vrai test du plateau), séries fichiers du niveau 5.
Mini-projets : gestionnaire v2 (tout en fonctions) puis + sauvegarde fichier.
Révisions : J+1, J+7 (fonctions), bilan hebdo.
Commits/push : ~8–10 commits, 5 push.
Livrable : v2 persistante.
Critère de réussite : face à un problème neuf, écrire le découpage en fonctions AVANT le code ; lire et écrire un fichier texte de tête.

Semaine 8 — Niveau 5 fin + niveau 6 début

Notions : try/except, imports, modules (j1–3) ; POO : classes, objets, __init__ (j4–6). Deuxième plateau en approche : le planning donne à la POO deux semaines et demie, c'est voulu.
Exercices : séries exceptions/modules, premières séries POO.
Mini-projets : v3 — gestion d'erreurs complète.
Révisions : J+1, J+7 (fichiers), bilan hebdo.
Commits/push : ~8–10 commits, 5 push.
Livrable : v3 robuste (aucun crash sur saisie hostile).
Critère de réussite : provoquer volontairement 3 exceptions différentes et les gérer ; écrire un premier __init__ de tête.

Semaine 9 — Niveau 6, cœur

Notions : méthodes, encapsulation, objets qui collaborent.
Exercices : toutes les séries POO, moyens et difficiles compris.
Mini-projets : v4 orientée objet (Task, TaskManager).
Révisions : J+1, J+7 (exceptions), J+30 sur les semaines 4–5 (mutabilité revisitée — elle éclaire la POO), bilan hebdo.
Commits/push : ~8–10 commits, 5 push.
Livrable : v4 fonctionnelle, même comportement que v3.
Critère de réussite : classe complète de tête ; expliquer à voix haute la différence entre une fonction et une méthode, et ce que self désigne.

Semaine 10 — Niveau 6 fin + niveau 7

Notions : consolidation POO (j1–2, aucune nouveauté) ; projets guidés du niveau 7 (j3–6).
Exercices : refaire de tête les 2 exercices POO les plus durs ; le reste de la semaine est du projet.
Mini-projets : premier projet guidé du niveau 7, en entier.
Révisions : J+1, J+7 (POO), bilan hebdo.
Commits/push : ~8–10 commits (rythme projet : commits plus petits et plus fréquents), 5 push.
Livrable : projet 7 terminé et poussé.
Critère de réussite : le projet marche de bout en bout ET tu peux expliquer chaque fonction/classe de ton code sans le relire ligne à ligne.

Semaine 11 — Niveau 8 + niveau 9 début

Notions : pytest, structure de projet, refactoring, docstrings (j1–4) ; HTTP, JSON (j5–6).
Exercices : écrire des tests pour ton projet du niveau 7 ; premières séries du niveau 9.
Mini-projets : ton projet 7 gagne des tests et une vraie structure.
Révisions : J+1, J+7 (projet 7), bilan hebdo.
Commits/push : ~8–10 commits, 5 push.
Livrable : pytest vert, projet restructuré.
Critère de réussite : un test échoue quand tu casses la fonction qu'il teste ; un appel HTTP réel parsé en JSON.

Semaine 12 — Niveau 9 fin + niveau 10 lancé

Notions : CSV, automatisation (j1–3) ; niveau 10 : choix du projet final, roadmap, premiers commits (j4–6).
Exercices : fin des séries niveau 9 + un script d'automatisation qui te sert vraiment.
Mini-projets : le projet final démarre.
Révisions : J+1, J+7, J+30 sur les semaines 8–9 (POO), bilan des 12 semaines dans le journal (relire le journal de la semaine 1 — c'est le moment « ne pas se décourager » à l'envers).
Commits/push : ~8–10 commits, 5 push.
Livrable : roadmap du projet final + v0.1 exécutable.
Critère de réussite : la v0.1 tourne. Le projet final continue ensuite à ton rythme (2–4 semaines) — comme pour le parcours 8 semaines, c'est la partie sans date, et c'est normal.

Parcours 4 — Rythme lent : 30 min/jour, sans date de fin

Pour qui : 30 minutes fiables, pas plus, mais tous les jours (ou presque). Routine : la « 30 minutes » de docs/methode.md, strictement. Ici on ne planifie pas par semaine — les semaines n'ont pas de sens à ce rythme — mais par niveau : un niveau est fini quand ses critères sont remplis, point.

Règle de calibrage : comptez 2 à 3 semaines par niveau (niveau 0 : 1–2 semaines ; niveaux 3, 4, 6 : plutôt 3, parfois 4 — ce sont les niveaux à plateau ; niveau 10 : le temps qu'il faut). Soit un parcours complet en 7 à 10 mois. C'est long, c'est honnête, et ça marche — à condition de tenir les règles anti-décrochage ci-dessous.

Par niveau, le contrat est toujours le même :

Notions : toutes les leçons du niveau, à raison d'une leçon par 2–3 sessions (jamais une leçon bâclée en une session de 30 min).
Exercices : toutes les séries, difficiles compris. Au rythme lent, les exercices sont encore plus importants qu'ailleurs : c'est eux qui maintiennent les notions vivantes d'une semaine sur l'autre.
Mini-projets : tous ceux du niveau, découpés en étapes de 7 minutes (le bloc « mini-projet » de la routine 30 min).
Révisions : J+1 à chaque session (l'échauffement de 5 min), J+7 au bilan hebdo, J+30 en routine mensuelle — au rythme lent, la révision espacée n'est pas une option, c'est elle qui compense la lenteur.
Commits/push : minimum 4–5 commits et 4–5 push par semaine (un par session). Un jour sans session = pas grave ; une semaine sans push = alerte.
Livrable de niveau : le(s) mini-projet(s) du niveau, terminés et poussés.
Critère de passage : la checklist de CHAQUE leçon du niveau cochée honnêtement + refaire de tête un exercice moyen de chaque leçon.

Règles pour ne pas perdre le fil (le vrai risque de ce parcours) :

Jamais deux jours OFF consécutifs planifiés. Un jour off ça arrive ; deux d'affilée, le fil casse. Si la vie impose une vraie pause : routine de reprise (docs/methode.md section 11), sans culpabilité.
Le bilan hebdo est sacré, même à ce rythme — c'est lui qui recolle les morceaux d'une semaine fragmentée. 30 min le dimanche : relire le code de la semaine, refaire un exercice raté, push propre, noter le programme de la semaine suivante dans le journal.
Toujours finir une session en notant la prochaine étape dans le journal (« demain : exercice 3 de la série dicts »). Démarrer une session de 30 min en cherchant quoi faire, c'est en perdre 10.
Une leçon entamée se finit avant d'en ouvrir une autre. Au rythme lent, deux leçons ouvertes en parallèle = deux leçons à moitié sues.
Le journal est ton fil d'Ariane. À 30 min/jour, tu oublieras où tu en es — c'est prévu. Le journal + PROGRESS.md + PROJECT_STATE.md te replacent en 2 minutes. Les tenir à jour n'est pas de l'intendance, c'est de la survie.

Choisir son parcours

Trois questions, dans cet ordre :

Combien de temps par jour, honnêtement, sur les 3 prochains mois ? Pas ta meilleure semaine — ta semaine MÉDIANE, avec les imprévus. 2 h+ → intensif. ~1 h → équilibré ou solide. 30–45 min → solide ou lent.
As-tu une échéance réelle (reconversion datée, projet pro) ? Oui → prends le parcours le plus rapide compatible avec ta réponse 1. Non → prends le parcours solide (12 semaines) : c'est celui qui maximise ce qui reste dans six mois, et c'est ça qui compte.
En cas d'hésitation entre deux parcours, prends le plus lent. Accélérer un parcours qu'on domine est agréable ; ralentir un parcours qui déborde est démoralisant. L'asymétrie décide.

Changer de parcours en cours de route (sans culpabiliser)

Les parcours partagent les mêmes niveaux, les mêmes leçons, les mêmes critères : changer de parcours, c'est juste changer de vitesse, jamais repartir de zéro. Tu te trouves au niveau 4 du parcours équilibré et la vie s'accélère ? Tu continues au niveau 4, en rythme lent. Rien n'est perdu, rien n'est à refaire.

Mode d'emploi du changement :

Décide au bilan hebdomadaire, pas au milieu d'une mauvaise journée. Une mauvaise semaine = on continue ; deux ou trois semaines de suite où le critère de réussite n'est pas atteint ou les sessions sautent = on change.
Note le changement dans le journal (une ligne : « passage au parcours solide à partir du niveau 4, raison : X ») et dans PROJECT_STATE.md. C'est une décision de pilotage documentée, pas un aveu.
Repère-toi par niveau, pas par semaine : « je suis au niveau 4 » est ta position ; le parcours ne fait que dire à quelle vitesse tu traverses les suivants.
Dans les deux sens : tu peux aussi accélérer si un parcours devient trop confortable (critères atteints en avance deux semaines de suite).

Le seul vrai échec possible est d'arrêter. Un parcours lent terminé bat un parcours intensif abandonné à la semaine 3 — de très loin. Choisis la vitesse qui te garde en mouvement.