Coder Legion - Recent posts tagged teaching

AI Lesson Planning for Teachers: How I Cut Prep Time in Half Without Losing the Human Touch

Sat, 31 Oct 2026 06:18:44 +0000

AI Lesson Planning for Teachers: How I Cut Prep Time in Half Without Losing the Human Touch

I am a head teacher at a government primary school in Punjab, and for years my evenings looked the same: a stack of notebooks, a syllabus outline, and lesson plans written by hand long after the school day ended. When I first tried AI lesson planning for teachers, I expected a gimmick. What I got instead was the single biggest change to my working week in years — my preparation time roughly halved, while my lessons actually got better. The catch, and it matters, is that the AI does the drafting and I do the teaching. Get that order backwards and you get slick-looking plans that fall apart in front of thirty children.

This is the honest version: the workflow I use, the prompts that work, and the guardrails that keep the human in charge.

What AI Lesson Planning for Teachers Actually Looks Like in a Real Classroom

Forget the marketing version where you type one sentence and a perfect lesson appears. Real AI lesson planning for teachers looks like this: you give the AI your topic, your class level, your time limit, and what your students already know, and it hands back a structured first draft — objectives, a timed sequence, questions, and a short activity. Then you do the part no model can do: you cross out what won't work for your children, you fix the examples so they match your students' lives, and you add the one story or question that makes the class pay attention.

In my school, a typical lesson is 35 to 40 minutes with a large class and limited materials. An AI that doesn't know that will happily plan a lesson needing a projector, printed worksheets for every child, and group work in sixes. So the first skill isn't prompting. It's knowing your constraints well enough to state them: class size, time, available materials, language level, and what the textbook actually covers. The AI is only as grounded as the brief you give it.

One more honest point: I teach from the Punjab textbooks, and the AI does not know my exact chapter — only the general topic. That gap is where a careless teacher gets into trouble, accepting a plan with the wrong scope or examples. My rule: the textbook is the syllabus, the AI is the assistant. Every plan gets checked against the chapter before it reaches the classroom.

My 30-Minute AI Lesson Planning Workflow

Here is the full workflow, timed honestly. It replaced an evening routine that used to take over an hour.

Step 1 — Pick one clear objective (3 minutes). Not "teach fractions" but "by the end of the lesson, students can shade and name one-half, one-third, and one-quarter of a shape." One objective, stated in student language. If you can't write it in one sentence, the AI can't plan around it either.

Step 2 — Write the brief (5 minutes). I paste the same structure every time: topic, class, time available, what students already know, materials I actually have (chalkboard, chart paper, the textbook), and one constraint ("no printing", "mixed ability class", "Urdu-medium explanations where needed"). This brief is the whole secret. A vague brief gives you a generic lesson; a specific brief gives you a usable one.

Step 3 — Generate the first draft (2 minutes). I ask for a timed plan: a 5-minute hook, 15 minutes of teaching, 10 minutes of practice, and a 5-minute check. I also ask for three questions at different difficulty levels and one activity that needs no materials beyond the board. The draft is never the final plan. It is raw material.

Step 4 — Edit like a teacher, not an editor (15 minutes). This is where the real work happens. I replace generic examples with local ones — market prices, cricket scores, the school garden — because children remember what they recognize. I delete any activity I can't run with my class size, check every fact and worked example against the textbook, and add the opening question I know will hook this particular class, because no model knows my students.

Step 5 — Make the exit ticket (5 minutes). Every lesson ends with one quick check: two questions on the board, answered on slates or in notebooks, that tell me before the bell whether the objective landed. If I skip this step, I am guessing about learning. The AI drafts the questions; I pick the ones that actually test the objective.

Total: about 30 minutes.

The Prompt Pattern That Keeps Lessons Honest

Most bad AI lessons come from one-prompt thinking: one long prompt, one accepted answer. A three-pass pattern fixes most of the quality problems people blame on the AI.

Pass 1 — Draft. "Plan a 35-minute lesson on [topic] for class [X]. Students already know [Y]. Materials: chalkboard and textbook only. Give me timed sections, three questions at easy, medium, and hard levels, and one no-material activity."

Pass 2 — Localize. "Rewrite the examples using everyday life in a Pakistani village school: market shopping, farming, cricket, family routines. Replace any activity that needs printing or a projector."

Pass 3 — Challenge. "Now find the weak points in this plan: where will students get confused, which step is too fast for a mixed-ability class, and what question checks understanding after the main teaching?" That third pass is the most valuable one — it surfaces the exact spots where a real class will struggle, and trains you to spot them yourself over time.

One warning from experience: never let the AI write your assessment questions unchecked. Models produce confident-sounding questions with wrong answers, especially in maths and science. Every question gets solved by me before it reaches the students. That single habit is the difference between using AI and being used by it.

AI Lesson Planning for Teachers: The Guardrails I Never Skip

AI lesson planning for teachers only stays honest if you hold a few lines firm. These are mine, learned the hard way:

The textbook decides the scope. If the AI's plan covers something outside the chapter, it gets cut, however interesting it looks. Exam alignment and student confidence both depend on this.
Every fact gets verified. Dates, science facts, worked maths examples, spellings — all checked before class. I once caught a wrong fraction example in a draft five minutes before the lesson. That was the day this rule became non-negotiable.
No student data goes into the AI. No names, no marks, no photos, no personal details. I describe the class in general terms ("mixed ability, 30+ students") and nothing more. This is a privacy line, not a preference.
The AI never writes the final word to students. Worksheets, notes, and homework pass through my eyes first. Anything the children read should sound like their teacher, not like a chatbot.
One new thing per lesson. If the AI suggests a new method and a new activity and a new grouping in the same lesson, I keep one and drop the rest. Classrooms punish overload faster than any reviewer will.

These guardrails are why my prep time halved instead of disappearing. The AI removed the blank-page work — structuring, sequencing, drafting questions — and left the judgment work to me. That is why the lessons got better, not just faster.

A Real Example: One Lesson, Before and After

Take a class 4 maths lesson on fractions, a topic where children either click or drown. My old hand-written plan was: introduce the term, draw two shapes on the board, do three textbook exercises. Serviceable, forgettable.

The AI-assisted version kept the same objective but changed the shape of the lesson. The hook became a real question: "If four friends share two rotis equally, how much does each get?" — something every child in my class has actually argued about. The teaching section used folding chart paper instead of just drawing, so children could see and hold the halves and quarters. Practice became a quick market game: "A shopkeeper sells half a kilo of sugar, then a quarter — how much is left?" And the exit ticket was two questions, one easy and one that catches the classic mistake of confusing the number of pieces with the size of each piece.

Nothing in that lesson required classroom technology. The AI contributed structure and variety; the classroom contributed the rotis, the market, and the paper-folding. AI lesson planning for teachers works best when the technology stays in the preparation room and the classroom stays human.

Your First-Week Checklist

If you want to try this yourself, here is the honest starter plan — one week, no overwhelm:

Pick ONE subject and ONE class to experiment with. Don't AI-plan everything at once.
Write your brief template once (topic, class, time, prior knowledge, materials, constraints) and reuse it every day.
Run the three-pass pattern: draft, localize, challenge.
Check every fact and every worked example against the textbook before class.
End every lesson with a two-question exit ticket, and keep the results — they tell you within a week whether the plans are actually working.
Steal the good parts: when a hook or activity lands well, save it in a personal bank for next year. After a term, that bank is worth more than any prompt collection.

A practical note for fellow Pakistani teachers: the free Punjab textbooks are all available online now, so you can read the chapter on your phone while drafting. I keep the full library linked from the Punjab textbooks hub on rehmanahmad.com, and I grab classroom utilities like PDF tools from filecobra.com when I need a printable for class. The tools support the teaching; they never replace it.

The Bottom Line

AI lesson planning for teachers is not about letting a machine teach. It is about letting a machine do the drafting so the teacher can do the teaching — better prepared, less exhausted, with the evening back. My prep time roughly halved, my lessons got more varied, and my students got hooks I would not have invented on a tired evening with a blank page.

But the bargain only holds if you keep the guardrails: textbook as syllabus, every fact verified, no student data shared, and your judgment on every page that reaches a child. Do that, and the AI becomes what it should have been all along — a tireless assistant to a teacher who is still, unmistakably, in charge.

If you try this workflow, start with one lesson this week and judge it by the exit ticket, not by how impressive the plan looked on screen.

GitHub Classroom has closed: what you still have, and how to run next term

Mon, 26 Oct 2026 16:09:06 +0000

Disclosure: I work on Uppcoder, one of the options listed at the end. The rest is about GitHub Classroom itself and applies whatever you choose.

GitHub retired GitHub Classroom on 28 August 2026. If your course ran on it, here is what is still there, what is gone, and what your choices are for the next term.

What happened, and when

GitHub closed new sign-ups to GitHub Classroom in May and retired it at the end of August. It now points educators to two partners: Classroom 50, free and open source from the Fifty Foundation, the nonprofit behind CS50, and Codio, a commercial platform.

26 May 2026: new sign-ups to GitHub Classroom closed
28 August 2026: GitHub Classroom retired; its website, APIs and related services decommissioned
GitHub's recommended partners: Classroom 50 and Codio

What you still have

GitHub says that GitHub accounts, repositories and organisations created to work with Classroom are not affected. Everything that lived in a repository is still where it was.

Your classroom organisation
Every student repository Classroom created, with its full commit history
Your template (starter) repositories
Any tests kept inside a repository, for example in a tests folder or a GitHub Actions workflow

What is gone, or going

GitHub says some Classroom data is being permanently deleted under its retention policies. GitHub's Classroom Export Utility downloaded this data as JSON and CSV files, but it worked through the Classroom APIs, which GitHub says are now decommissioned. If you ran it before 28 August, keep those files; if you did not, plan to rebuild what is listed here.

Classroom and assignment names
Tests defined in Classroom itself rather than in a repository (autograding set up on the Classroom website)
LMS-integrated rosters: the LTI link between Classroom and Moodle, Canvas and the rest

Finding your students' repositories

Classroom named each student repository after the assignment and the student's GitHub username, so the repositories of one assignment share a prefix. With the GitHub CLI (gh) you can list them, and clone them all into one folder. The roster that matched usernames to students was Classroom data; rebuild it from your LMS class list or your own records if you need it.

# list one assignment's repositories
gh repo list YOUR-ORG --limit 1000 --json name -q '.[].name' | grep '^assignment-prefix-'

# clone them all into the current folder
gh repo list YOUR-ORG --limit 1000 --json name -q '.[].name' | grep '^assignment-prefix-' \
  | xargs -I{} gh repo clone YOUR-ORG/{}

Before next term: a checklist

Whatever you use next, these steps keep last term's work safe and make the next one easier to set up.

Keep the organisation. Archive last term's student repositories rather than deleting them, if your school's retention rules allow it
Move tests into the template repositories, in a tests folder, so they travel with the assignment whatever tool you use next
Write down the assignment list with each template repository and its due dates, since the names in Classroom are being deleted
Check your LMS: if Classroom was linked to Moodle, Canvas, Blackboard or Brightspace, remove the old activity so students don't click into a dead end
Pick the replacement before the term starts and try one assignment end to end with a test student account

The options for next term

Each takes a different approach; which fits depends on your course, your school's rules on student data, and how much you want to run yourself.

Classroom 50 (free, open source, the Fifty Foundation): closest to GitHub Classroom, with assignments from template repositories, autograding through GitHub Actions, rosters and submissions, on GitHub. Needs an organisation on a GitHub Team or Enterprise plan (free for verified educators through GitHub Education) and a token with read and write access to the organisation's repositories
Codio (commercial, a GitHub partner): a hosted platform for coding courses with its own content, environments and autograding, and migration guides for GitHub Classroom users
Do it yourself with the GitHub CLI: for small courses, create the student repositories from a template with gh and a list of usernames, and mark by hand or with your own GitHub Actions; community tools shared in GitHub's own discussion of the change do this for you
Uppcoder (that's us; commercial, with a free tier): assignments are git repositories with starter code, tests and a solution; every student works in the same ready environment in the cloud, so nobody installs anything; tests mark each hand-in and you mark the rest by rubric; hand-ins can stay in your own GitHub organisation; it works inside Moodle, Canvas, Blackboard and Brightspace over LTI 1.3, or on its own;

If you choose Uppcoder: for teachers moving from GitHub Classroom we move one course across for you, up to ten of its assignments, and it runs free until 30 June 2027 (first 20 courses, one per teacher, up to 40 students, apply by 15 December 2026). Details: https://portal.uppcoder.com/github-classroom-alternative?utm_source=coderlegion&utm_medium=blog&utm_campaign=posts&utm_content=post-146

Sources

https://portal.uppcoder.com/github-classroom-closed?utm_source=coderlegion&utm_medium=blog&utm_campaign=posts&utm_content=post-146

The Rs 20 Pencil Bank: How My Class 2 Stopped Losing Pencils Every Day

Mon, 26 Oct 2026 04:49:31 +0000

The Rs 20 Pencil Bank: How My Class 2 Stopped Losing Pencils Every Day

From The Head Teacher's Diary — real stories from a primary-school classroom in Yazman, Pakistan. Entry No. 1.

Every morning, the same complaints waited for me at the classroom door.

A pencil was lost. An eraser had disappeared. A sharpener was nowhere to be found. And behind those small complaints stood a bigger problem: the parents of my students are poor. A pencil costs little, but when a child loses stationery almost every day, "little" stops being little. Children were taking money from home daily for replacements — and at home, that money came out of an already tight budget.

I am the head teacher of my primary school, and also the in-charge of Class 2. So this was my problem to solve, twice over.

The Problem Was Not the Children

The easy response is to scold. "You are careless. Look after your things." Every teacher has said it; I have said it myself.

But watch the situation honestly: a six or seven year old, a full day of lessons, playtime, bags being opened and closed a dozen times — and no place, no system, no routine for keeping three small items safe. We were expecting small children to protect stationery with nothing but memory and fear of scolding.

Teachers everywhere know this as the problem of disappearing pencils — and it is rarely solved by buying more pencils.

The children were not the problem. The absence of a system was.

So instead of another lecture, I built a system.

Every Child Gives Rs 20 — Once

I told the class: every child will bring Rs 20. Not every day. Just once, into one shared collection.

From that collection, we bought pencils, erasers and sharpeners for the whole class — together with a small bin to keep them in. From that day, the stationery stopped belonging to individual children. It belonged to the class — community supplies, owned by everyone and cared for by everyone.

Then came the part that made it work: two students are on duty every day.

In the morning, the duty students hand out a pencil, an eraser and a sharpener to every child.
At closing time, they collect everything back from everyone and place it in the bin.
The next morning, the same routine begins again.

That is the whole system. No register, no software, no expense beyond the first collection.

The whole system in one picture: one red bin, and every pencil, eraser, sharpener and ruler belongs to the class — not to any one child.

What Changed

The results surprised even me.

A pencil now lasts about two weeks. Before the pencil bank, a pencil could vanish the same day it was bought. Now the same pencil keeps coming back to the bin every evening, so it survives until it is genuinely used up.

The daily money stopped. Earlier, children asked for money at home almost every day for a lost item. Now the collection happens once, and the next one is needed only after roughly two weeks. For a poor household, removing a daily small expense is not a small thing.

The complaints ended. The morning queue of lost-pencils simply disappeared, because there is nothing left to lose — everything returns to the bin.

And something less visible grew: responsibility. The duty students take their job seriously. Collecting from everyone, missing no one, keeping the bin in order — that is trust, and children rise to meet trust. The whole class cares for the stationery now, because it is ours. A personal pencil got lost. The class pencil gets protected.

Why It Works

Looking back, three things made the difference:

Ownership changed. What belongs to everyone is watched by everyone.
The routine is daily and visible. Out in the morning, back at closing. Nothing depends on a child's memory at home.
The cost is shared and tiny. Rs 20, once in a while, never burdens one family — and no child is singled out, because everyone is an equal shareholder in the bank.

Try It in Your Classroom

If your class has the same morning complaints, the recipe is simple:

Fix a small, equal contribution every child can afford — for us it was Rs 20.
Buy the stationery for the whole class from the pooled money, plus one box or bin.
Put two students on duty daily — hand out in the morning, collect everything at closing.
Rotate the duty so every child serves.
Keep the collection and spending open and simple; the class should always know where the money went.

You do not need permission, a budget line, or an NGO. You need Rs 20 per child and the decision to fix the system instead of the child.

The Lesson I Took Home

Teaching is full of problems we blame on children: lost things, forgotten things, unfinished things. This small experiment taught me to ask a different question first — is there a system, or am I expecting a seven year old to be one?

A pencil bank will not transform education. But it turned a daily complaint into a daily lesson in sharing, duty and care — and it costs less than the price of the pencils we were losing.

If you try it in your school, I would genuinely like to hear how it went.

— Rahman Ahmad Chaudhary, Head Teacher, GPS 117 DB(BJ), Yazman. More entries from The Head Teacher's Diary are on the way.

FAQs

How do you solve the problem of disappearing pencils in the classroom?
Stop treating each pencil as private property. Pool a tiny equal contribution (we used Rs 20 per child), buy stationery for the whole class, store it in one bin, and have two duty students hand it out every morning and collect it back at closing. When stationery belongs to the class and returns to one place daily, losses almost disappear.

How do you manage classroom stationery when parents cannot afford supplies?
Spread the cost thin and share it. Our pencil bank runs on Rs 20 per child, collected roughly once every two weeks — far cheaper for poor families than replacing a lost pencil, eraser or sharpener every other day, and no child is singled out because everyone contributes equally.

What is a class pencil bank?
A pencil bank is a simple classroom system: stationery is bought from a small pooled contribution, owned by the class, kept in a shared bin, and distributed and collected daily by students on duty. In my Class 2 it stretched one pencil's life to about two weeks and ended daily lost-stationery complaints.

POSSE Project Evaluator

Mon, 22 Jun 2026 20:55:18 +0000

POSSE Project Evaluator

A few days ago, I reflected on my experience at the Professors' Open Source Software Experience (POSSE) workshop, a three-day event focused on integrating HFOSS into classroom settings. One of the most practical takeaways was focusing on project health checks to evaluate whether an open-source repository is a good fit for students. The workshop introduced a 9-criterion rubric (scored 0-2, 18 points max) that instructors can use as a quick first pass.

The workshop provided a guided example, interactive activity to review an existing project, and unconference time for participants to devote to planning for OSS integration into their courses. I found the rubric very helpful for systematically assessing whether candidate projects are active, well-maintained, etc., but I quickly found that applying it manually to repositories was time-consuming and tedious. In particular, for each project I had to:

Visit each repo's GitHub page;
Check the license file, veryfing whether it existing and was an OSI-approved license;
Scan the commit graph for recent activity;
Count the number of contributors;
Look for CONTRIBUTING.md and CODE_OF_CONDUCT.md files;
Check stars, forks, releases, etc.;
Enter these results with evidence into the rubric table for documenting;
...and repeat for every candidate project

To help with this, I built a tool to automate it.

Automating the Rubric

My original goal was to implement this manually, but I quickly realized that I did not have the time available to commit to writing the code myself. Thus, leveraging the help of generative AI (opencode 1.17.8 with opencode/big-pickle), posse_project_eval.py was implemented. The POSSE Project Evaluator is a Python CLI that scores any public GitHub repository against the full POSSE rubric using the PyGitHub library to inspect a repo across all nine criteria:

Criterion	What it checks
Licensing	OSI-approved open source license?
Technology	Top languages match your preferred stack?
Level of Activity	Commits across the last four quarters?
Number of Contributors	Size of the contributor base
Project Size	Estimated lines of code
Issue Tracker	Open issues and recent activity?
New Contributor	CONTRIBUTING file and community profile?
Community Norms	Code of Conduct present?
User Base	Stars, forks, and releases?

The benefits of this approach are:

It can score multiple candidate projects in seconds, reducing effort to pre-screen projects;
Criteria are configurable based on instructor/course preferences (e.g., technology, project size, etc...);
The results are repeatable for measuring and comparing OSS project health;
In cases where students will need to select their own projects, they can also run this tool to compare OSS projects;
Results along with rationales are presented in a readable table (see sample below), which can also be saved to an output file.

================================================================================
FOSS Project Name: OED
Description: Open Energy Dashboard
Repository: https://github.com/OpenEnergyDashboard/OED
================================================================================
Licensing — Level 2/2
  Data:   mpl-2.0
  Source: https://github.com/OpenEnergyDashboard/OED/blob/main/LICENSE
  Reason: OSI-approved open source license
--------------------------------------------------------------------------------
...
Total Score: 16/18

Agentic Evaluations 🤖

Given the rise in generative AI and agents for automating tasks, the repository also includes AI-optimized files. This includes a skill definition with the full rubric and an agent workflow for conversational evaluation.

The agent should ideally be able to run for any agentic coding assistant (i.e., Claude Code, opencode, etc.), invoked using @project-evaluator with a given repository/list of repositories to evaluate. While these results may not be as repeatable, they are derived conversationally and could incorporate additional contexts. The agent by default bases responses on the results of the Python script, but can also use it's own web fetching capabilities if preferred.

Try It Out!

More details on installing, configuring, and running the POSSE Project Evaluator are available in the project README. The tool is MIT-licensed and available at github.com/chbrown13/posse_project_eval. If you're an instructor considering integrating HFOSS into your course or a developer interested in assessing projects to contribute to in your own time, feel free to try it out! Pull requests, issues, and suggestions are also welcome!

Who is a good teacher?

Thu, 07 May 2026 05:58:51 +0000

I am an accidental teacher. About 3 years ago, I discovered I have a knack for teaching, and since then, I have been teaching.

Over this time period, I realised there’s one highly underrated trait:

Asking questions.

Not to test learners.
Not to put them on the spot.

But to make them think.

Questions are not only for evaluation. They could be tools for thinking if used correctly.

Learners do not always need to know the answer.

What matters is that they try to recall.

They think.

Because once the mind has struggled with a question, even briefly, it appreciates the answer more and the explanation sinks in much better.

So, in my limited experience, a good teacher is the one who creates moments of thought by asking the right questions clearly.

Thoughts?