Enseigner le code au cycle 3 : le guide enseignant

Que disent les programmes sur la programmation au cycle 3 ?

Au cycle 3 (CM1, CM2 et 6e), l'initiation à la programmation n'est pas une option : elle figure dans les programmes officiels, principalement en mathématiques et en sciences et technologie. L'objectif n'est pas de former de futurs développeurs, mais de développer la pensée algorithmique — la capacité à décomposer un problème en étapes claires et ordonnées — et de faire écrire aux élèves de premiers programmes simples.

Concrètement, les attendus tournent autour de quelques idées clés : programmer des déplacements et des tracés, repérer une position dans un quadrillage, utiliser des instructions qui se répètent (boucles), déclencher une action selon une condition. Le code est ainsi un outil au service des mathématiques (repérage, angles, mesures, géométrie) et du raisonnement, pas une matière isolée.

• Décrire et exécuter un algorithme simple sous forme d'une suite d'instructions.
• Programmer des déplacements et des tracés (avancer, tourner, répéter).
• Se repérer et déplacer un objet dans un quadrillage ou sur un plan.
• Utiliser des boucles pour répéter et des conditions pour réagir à une situation.
• Tester, repérer une erreur et corriger son programme (débogage).

Faut-il savoir coder pour enseigner le code en CM1, CM2 ou 6e ?

Non. C'est l'inquiétude la plus répandue chez les enseignants de cycle 3, et c'est une fausse barrière. Le niveau attendu reste celui de l'initiation : séquences, boucles et conditions suffisent largement. Vous n'avez pas à maîtriser un langage professionnel ni à anticiper toutes les solutions des élèves. Votre rôle est pédagogique avant d'être technique.

La posture la plus efficace en classe est celle de l'accompagnant : faire chercher plutôt que donner la réponse, transformer chaque bug en question (« Que voulais-tu obtenir ? Qu'observes-tu à l'écran ? »), et présenter l'erreur comme une information utile, pas comme une faute. Cette approche développe l'autonomie et la persévérance des élèves — et vous dispense d'avoir réponse à tout. Beaucoup d'enseignants découvrent d'ailleurs l'outil en même temps que leur classe, sans que cela nuise à l'apprentissage.

Par où commencer ? Le code débranché avant l'écran

Avant d'allumer le moindre ordinateur, le « code débranché » (sans écran) est la meilleure entrée en matière au cycle 3. Il installe la logique algorithmique avec un matériel minimal — papier, grille, flèches, déplacements dans la cour — et permet de faire travailler toute la classe en même temps, y compris quand l'équipement informatique est limité. C'est aussi un excellent moyen de dédramatiser la programmation auprès des élèves comme de l'enseignant.

L'activité phare est le jeu du « robot humain » : un élève donne une suite d'instructions précises (« avance de 3 cases, tourne à droite, avance de 2 cases ») et un camarade les exécute à la lettre, sans rien deviner. Les oublis et les ambiguïtés deviennent visibles et amusants, ce qui ancre l'idée qu'un algorithme doit être complet, précis et ordonné. On passe ensuite naturellement à l'écran, où l'élève retrouve ces mêmes notions avec un résultat immédiat.

• Le jeu du « robot humain » : un élève dicte les instructions, un autre les exécute sans interpréter.
• Tracer un parcours sur un quadrillage avec des flèches (avance, tourne, répète).
• Décrire la « marche à suivre » d'une tâche du quotidien (recette, trajet) étape par étape.
• Faire repérer une erreur dans un algorithme volontairement faux, et la corriger collectivement.
• Coder un déplacement à la voix, puis l'écrire sous forme de liste d'instructions.

Quels outils pour enseigner le code au cycle 3 ?

L'outil de référence au cycle 3 est Scratch, un environnement gratuit où l'on programme par blocs visuels à glisser-déposer : il évite les erreurs de syntaxe et permet de créer des animations et des jeux. C'est souvent un excellent premier pas. À côté, plusieurs plateformes en ligne proposent des parcours guidés d'exercices, et le code-dessin façon tortue (héritier du langage Logo) reste une porte d'entrée très efficace pour relier programmation et géométrie.

Pour choisir, gardez quelques critères simples et discriminants : un outil en français, une vraie exécution du code (l'élève lance son programme et voit le résultat, plutôt que de répondre à des QCM), une progression adaptée aux 8-12 ans, et un cadre conforme au RGPD, point sensible et obligatoire dès qu'il s'agit de données d'élèves mineurs.

• Privilégier un outil en français, lisible et adapté au niveau cycle 3.
• Vérifier que l'élève exécute réellement son code et observe le résultat (pas seulement des QCM).
• Choisir une progression par concepts : séquence, puis boucle, puis condition.
• S'assurer de la conformité RGPD et de la minimisation des données d'élèves.
• Préférer des séances courtes avec une réussite visible à la fin de chaque séance.

Une progression simple et concrète sur l'année

Inutile de bâtir un cours d'informatique complet : une progression par paliers, branchée sur les mathématiques, suffit largement. L'idée est d'introduire un concept à la fois, de le faire manipuler, puis de le réinvestir dans un petit projet motivant. Chaque notion gagne à être d'abord vue en débranché, puis pratiquée à l'écran, où l'élève voit immédiatement l'effet de ses instructions.

Voici un cheminement éprouvé, à adapter selon votre niveau de classe (CM1, CM2 ou 6e) et votre équipement. L'essentiel est la régularité de courtes séances plutôt que de longues sessions ponctuelles, et le fait de toujours laisser l'élève tester et corriger lui-même.

• Étape 1 — La séquence : écrire une suite d'instructions dans le bon ordre (déplacements, tracés simples).
• Étape 2 — La boucle : repérer une répétition et la remplacer par « répète… » (carré, escalier, polygone).
• Étape 3 — La condition : faire réagir le programme selon un cas (« si… alors… »).
• Étape 4 — Variables et compteurs : retenir une information (un score, un nombre de tours).
• Étape 5 — Le débogage : analyser un programme qui ne fait pas ce qu'on voulait et le corriger.
• Étape 6 — Un mini-projet : un dessin géométrique, une animation ou un petit jeu à présenter.

RGPD et données des élèves : un point à ne pas négliger

Dès que des élèves utilisent un outil numérique, la question des données personnelles se pose, et elle relève d'une obligation, pas d'un détail. À l'école, le principe de minimisation s'impose : on ne collecte que le strict nécessaire, on évite d'exposer le nom, le prénom ou toute donnée identifiante des enfants, et on privilégie des services hébergés et conformes au RGPD. Renseignez-vous toujours sur ce que l'outil collecte et où sont stockées les données avant de l'introduire en classe.

Quelques bons réflexes limitent les risques : créer des comptes par identifiant et code plutôt que par e-mail personnel d'élève, ne jamais saisir d'informations sensibles, et vérifier la politique de confidentialité de la plateforme. C'est un point d'attention particulièrement important avec les outils intégrant de l'intelligence artificielle, où il faut s'assurer qu'aucune donnée identifiante d'élève n'est transmise au modèle.

• Appliquer la minimisation : ne collecter que ce qui est indispensable.
• Éviter d'exposer prénom, nom ou photo des élèves dans l'outil.
• Privilégier des comptes par identifiant + code, sans e-mail enfant.
• Vérifier l'hébergement, la politique de confidentialité et la conformité RGPD.
• Avec une IA, s'assurer qu'aucune donnée identifiante d'élève n'est envoyée au modèle.

Un exemple d'outil aligné sur ces exigences

Pour illustrer concrètement ces critères, Early Eyes est une application française pensée pour les 8-12 ans, donc directement utilisable sur la tranche du cycle 3. L'élève y écrit du vrai code qui dessine à l'écran, à la façon de la tortue Logo, et exécute son programme pour voir le résultat : il y a une vraie validation du code, pas un QCM. La progression est structurée en 6 mondes, 33 leçons et 17 quiz, ce qui en fait un support clé en main pour qui débute, en classe comme à la maison.

Côté accompagnement, le tuteur IA « Early » guide l'élève par indices progressifs sans jamais livrer la solution toute faite — exactement la posture recommandée en classe — et valorise l'erreur. Côté données, le dispositif est pensé RGPD by design : le prénom de l'enfant n'est jamais envoyé à l'IA et les comptes fonctionnent par identifiant et code, sans e-mail enfant. Des réglages adaptés aux élèves DYS (polices et confort de lecture) et un accès freemium pour tester complètent un cadre rassurant. Quel que soit l'outil retenu, l'essentiel reste le même : l'élève doit voir le résultat de son code, comprendre son erreur et la corriger lui-même.

Un exemple de code : dessiner un carré avec une boucle

; D'abord SANS boucle : on répète 4 fois les mêmes instructions
; (on voit vite que c'est long et répétitif)
avance 100      ; trace un côté de 100 pas
tourne 90       ; pivote de 90° (angle droit)
avance 100
tourne 90
avance 100
tourne 90
avance 100
tourne 90

; Ensuite AVEC une boucle : on repère la répétition
; et on la remplace par « répète… »
répète 4 fois :
    avance 100  ; un côté du carré
    tourne 90   ; un angle droit
; -> 4 côtés + 4 angles de 90° = un carré complet

; Pour aller plus loin : changer le 4 et l'angle dessine
; d'autres polygones (triangle = répète 3, tourne 120)

Une progression sur l'année, étape par étape