Homeschool Lesson Planner: AI-Powered Multi-Framework Curriculum Planning

Three Curricula, Three Kids, One Spreadsheet Meltdown

How do you plan a week of lessons when your family runs three curricula at once?

We homeschool our three children — Kindergarten, Grade 2, and Grade 4 — from our home in Bogor, just south of Jakarta. Each child follows three curriculum frameworks simultaneously: Indonesia's Kurikulum Merdeka (the national "freedom curriculum"), the IB Primary Years Programme (PYP), and New York State Next Generation standards. Every framework has its own scope and sequence, its own pedagogical philosophy, its own pacing.

I spent the first semester doing this by hand in Notion. It took hours every Sunday night. The structure was the same each week — five days, two teaching blocks per day, materials lists, anchor questions — but the content required real judgment. Which NYS standard aligns with which Merdeka competency this week? What read-aloud ties the PYP inquiry thread to the math concept? You can't template your way to answers like that.

So I taught Claude how to do it.

What the Skill Does

The homeschool-lesson-planner is a Claude Code skill — a prompt file, not compiled code — that drafts complete weekly lesson plans directly into our Notion workspace. I say "plan Week 3" or "draft the next unit," and Claude validates the unit context against prior weeks, creates structured Notion pages with five days of activities (materials checklists, anchor questions, differentiated paths for each grade level), wires up related database entries for Books, Materials, and Sensory Activities with proper Notion relations, and respects our pedagogical constraints without being reminded.

That last point is the important one. The skill doesn't just fill in boxes. It makes pedagogical decisions.

Pedagogical Design Decisions

These principles emerged from months of trial and error — mostly error. Early versions produced plans that were structurally correct but felt dead on the page. The rules that survived:

Day 4 is the conceptual high point; Day 5 is synthesis. The week builds toward a peak challenge on Thursday, then Friday consolidates with a family read-aloud closer. I tried putting the hardest material on Monday (the "rip off the bandaid" approach). It was a disaster. The kids need ramp-up time.

Indonesian context is not decoration — it's the default. Currency problems use Rupiah. Geography lessons reference Borobudur, not the Grand Canyon. Population data comes from BPS (Badan Pusat Statistik, Indonesia's statistics bureau), not the US Census. We live here. The curriculum should reflect that.

Per-day materials checklists only. Never dump a full week's materials list at the top. My wife Nurul preps materials morning by morning — a week-long list is just noise. Each day's section lists exactly what she needs to have ready for that day's sessions.

Body & Brain Ready warm-ups open every session. Three minutes of sensory regulation before academic work begins. Rolling playdough, balancing on one foot, clapping patterns. This came from our occupational therapist's recommendation and it works.

Database Schema

The skill operates across 11 interconnected Notion databases. The diagram below shows how they relate — from semesters down through units and weekly lesson plans to individual teaching sessions:

erDiagram
    Semesters ||--o{ Units : contains
    Units ||--o{ Lesson_Plans : "has weeks"
    Units }o--|| Theme_Ideas : "themed by"
    Units ||--o{ Lines_of_Inquiry : explores
    Units }o--o{ Books : references
    Units }o--o{ Materials : "needs"
    Lesson_Plans }o--o{ Lines_of_Inquiry : covers
    Lesson_Plans }o--o{ Books : "read-aloud"
    Lesson_Plans }o--o{ Materials : requires
    Lesson_Plans }o--o{ Sensory_Activities : "warm-up"
    Lesson_Plans }o--o{ Daily_Time_Blocks : "scheduled in"
    Lesson_Plans ||--o{ Sessions : "taught as"
    Lesson_Plans }o--o{ Lesson_Plans : "blocks / blocked by"
    Daily_Time_Blocks }o--o{ Sensory_Activities : uses
    Sessions }o--o{ Sessions : "blocks / blocked by"

    Semesters {
        title Name
        date Date_Range
        formula Code
    }
    Units {
        title Unit_Title
        select Status
        date Date_Range
        rollup PYP_Theme
        rollup Sem_Code
    }
    Theme_Ideas {
        title Theme
        text Summary
        select Status
        select PYP_Theme
        multi_select Curriculum
    }
    Lines_of_Inquiry {
        title Title
        text Big_Question
    }
    Lesson_Plans {
        title Lesson_Title
        number Week
        text Big_Question
        select Status
        multi_select Subjects
        date Date_Range
        rollup Teacher
        rollup Semester
    }
    Daily_Time_Blocks {
        title Block
        text Time
        multi_select Day_of_Week
        multi_select For_Whom
        person Teacher
        select Block_Type
        multi_select Subjects
    }
    Sessions {
        title Session
        date Date_and_Time
        person Teacher
        select Status
        select How_it_Went
        rollup Subjects
        rollup Unit
    }
    Books {
        title Title
    }
    Materials {
        title Name
        select Status
    }
    Sensory_Activities {
        title Activity
    }
    Milestones {
        title Milestone
        select Subject
        select Grade
        checkbox Merdeka
        checkbox PYP
        checkbox NYS
        formula Overlap
    }

Architecture

The whole thing is a single SKILL.md file that teaches Claude how to interact with our Notion workspace. No compiled code. No backend service. No API keys beyond what the Notion MCP server already provides.

The file carries three things: a reference mapping every Notion database ID, property name, and schema detail; a page skeleton defining the day-by-day structure Claude should follow; and a canonical example — Week 1, "Place Value Power-Up" — showing exactly what good output looks like. That canonical example turned out to be the most important piece. More on that in a moment.

Claude uses the Notion MCP tools to create pages, set properties, and wire up relations. The skill handles our Ibu-mornings / Ayah-afternoons teaching split, with my afternoon blocks (two 90-minute academic sessions) as the primary planning scope.

What I Learned

The hardest part was not the Notion integration. It was encoding taste.

Early versions of the skill produced technically correct but pedagogically flat plans. The activities checked every box — right standard, right grade level, right subject — but they felt like they'd been generated by a committee. No arc to the week. No moment where a kid would look up and say "wait, really?"

The breakthrough was the canonical example. I took one week that had gone beautifully in practice — the lessons landed, the kids were engaged, the materials flowed — and wrote it up in exact detail. Showing Claude a single week done exactly right taught it more than pages of abstract rules ever did. The model didn't need more constraints. It needed a worked example of what good looks like.

The three-framework constraint, meanwhile, turned out to be an advantage rather than a burden. When NYS, Merdeka, and PYP all point at the same concept from different angles, the resulting lesson is richer than any single framework would produce. The skill's job is to find those convergence points — and it does, reliably, in the time it takes me to type "plan next week."

Next I want to add retroactive feedback: after a week of teaching, tell the skill which lessons worked and which didn't, and let it adjust its model of what "good" means for our family. That loop isn't built yet. But the structure is ready for it.