I want to show you the flow, not a polished plan. This is roughly how it actually went — me bringing a vague itch to learn something, an AI as a thinking partner, and the two of us figuring it out live, with course-corrections and all. If you take one thing from it, let it be the method — you can run the same loop for whatever you’re curious about.

A quick honest frame before the story: in the AI era it’s dangerously easy to feel like you learned something because something got produced. I wanted the opposite — to use AI not to hand me answers, but to help me build a path I’d actually walk, and to keep testing whether the understanding was real.

Why I picked something I know nothing about

I work in AI/ML. I could’ve made a slick curriculum in my own field and looked smart. But that would’ve been performing expertise, not learning. So I deliberately picked something I’m genuinely at zero on: Algorithmic Game Theory (AGT) — a field I’d been circling for years, and was once told I lacked the background to take a course in. That “come back when you’re ready” gate was exactly the friction I wanted to dissolve, out in the open.

I said this to the AI first — not “teach me AGT,” but “help me build a way to learn it, and keep me honest.”

First move: set the stance, not the syllabus

Before any content, we agreed how this should feel:

  • A brainstorm, not a roadmap. I didn’t want a syllabus to obey — I wanted a map I understand well enough to redraw.
  • Guard against the illusion of learning. Every unit needs a cheap test that the model actually formed — predict before you reveal, simulate from scratch, solve a new problem.
  • Top-to-bottom, then atomic. See the whole landscape and how it wires together first; then zoom into one atom and go deep.
  • Tiny experiments (from Anne-Laure Le Cunff’s book). Small, reversible steps. The next move is always small enough to take.

Then we started at the top and zoomed in

We began with the whole landscape — AGT as six regions and, crucially, the wiring between them. One tension holds the field together: incentives vs. computation. Then the abstract: what is this, and how is it different from “algorithms” and from “games”? The line that made it click for me:

In algorithms, the input is a passive object you process. In games, the “input” is a crowd of self-interested agents who react to your rules. AGT is algorithm design against inputs that push back.

Where I pushed back (this is the good part)

The flow wasn’t one-directional. I kept steering, and each nudge improved it:

  • “Where does this live in today’s AI?” AGT can read like dusty 2007 economics. So we mapped where it’s the operating theory of multi-agent AI: GAN training is a game; superhuman poker (Pluribus) runs on no-regret learning; RLHF is secretly social choice.
  • “Don’t blur the two senses of agent.” A game-theory “agent” is anything with incentives — historically a human or a firm. An “AI/LLM agent” is software. They only intersect. AGT is substrate-agnostic, which is exactly why it applies to human systems and to AIs as they become economic actors.
  • “Give me real, taught resources — not papers.” A paper compresses years into a dense few pages; it’s a terrible on-ramp. We ordered everything by accessibility: interactive explainers → professors’ lecture notes → engineering blogs → handbook → papers last.
  • “Make it a real 15 weeks, but earn it.” Five weeks of solid foundations, then ten to go deep — trimming the over-templated bits to buy room for the evergreen stuff.
  • “The thing I actually want to apply it to.” Your recommendation feed — YouTube, X, LinkedIn — isn’t a passive ranker; it’s a multi-sided game where the platform, users, and creators all chase incentives, and engagement-maximizing can settle into a bad equilibrium (clickbait). That became two flagship weeks.

Every one of those was me reacting to a draft, not accepting it. That back-and-forth is the method.

The plan — and the moment I loosened it

We ended up writing all fifteen weeks in detail: what to read, the theory to work through by hand, questions to wonder about, and an experiment as the spine of each week.

Then I hit the real lesson. As I read the weeks, I realized 5 hours wouldn’t cut it — to actually learn (not survey) I’d want 8–10. So we relaxed the timing. But more importantly, we changed the stance on timing:

Don’t over-condition a personal curriculum. Too many rules and hour-budgets and you’ve rebuilt the intimidating thing you were trying to escape. If it grips you, go all in. If life gets busy, let it stretch. The hours are a floor to flex, never a ceiling.

And this is where it gets personal, in the literal sense. I’m keeping mine loose on purpose — I have other commitments, so I’m giving myself room to explore, treating these 15 weeks as orientation and a first pass, with the honest plan that a later pass goes further. But if you’re adapting this and you’re learning full-time — 8 or 10 hours a day — you’d set a completely different expectation: compress the weeks, go deeper in each, push much further in the same calendar time. Calibrate the plan to your own time and energy, not to mine. That personalization is the feature — a personal curriculum should fit the person.

What I’m actually expecting (and what I’m not)

Here’s the honest part. I probably won’t “finish” all fifteen weeks on schedule — and that’s not failure. I’m not trying to become an expert in fifteen weeks; nobody does that.

What I am expecting is to go from subzero to a genuinely good position: to have the map in my hand — knowing what to learn next, what to try, what’s worth exploring — and to have built real intuitions. The concrete test I care about: if a matching problem or a mechanism-design problem lands on my desk, I want to be able to recognize it, think about it, and start working it — where today I’d have no handle at all.

Comfort and capability, not a certificate. A curriculum like this should leave you able to keep going on your own — and it should keep evolving as you do.

One more thing I had to make peace with: it’s not linear

The sneakiest lie in how we’re taught is that learning is a checklist — read it, tick the box, “understood,” next. It isn’t. Understanding spirals. You grab a concept 70% the first time, move on before it’s complete, and it clarifies when you come back to it — often much later, once the next idea gives it context. I’ve felt this hard: in causal inference, it was working the applied side that made the theory get sharper and sharper — and then re-reading closed the loop. So this curriculum is deliberately experiment-anchored: the building isn’t a reward after the math, it’s the tool that makes the math legible. If you take that seriously, you stop blocking on “did I fully get it?” — you note the gap, do the thing, move on, and trust the return trip. And you give yourself the actual apparatus for it: brainstorming with the AI, teaching it back in your own words, flashcards for the glossary, a doubt log, a quick math refresher when one inequality is in the way. Reading at a laptop is one tool of many, not the whole act.

The quiet enemy: wanting to be a pro by Tuesday

If I’m honest, the thing most likely to kill this isn’t the math — it’s impatience. You start something and within two days a part of you wants to already sound like an expert. When that doesn’t happen (it never does), the disappointment curdles into backlog guilt, and you quit before finishing even the “hello world.” I’ve watched myself and others do this.

So I’m giving myself explicit permission to be a beginner and to go slow — the goal is to slowly gain control of the subject, not to fake fluency by Tuesday. Small real wins (“I reproduced Braess,” “I can explain a second-price auction to a friend”) are the dopamine I actually get to keep. Slow and compounding beats fast and fake.

One optional thing that helps: learning in public — if it energizes you. Sharing what you learned, or even just your open questions, on LinkedIn or X (or a scrappy video) tends to pull in answers and people walking the same path. Or skip the posting and just connect quietly with others exploring it. It’s not for everyone, and it’s not required — the only real failure mode is stopping.

Run this loop for your own subject

The subject was AGT; the method is subject-agnostic:

  1. Pick something you’re honestly at zero on — and say your current understanding out loud. That “before” snapshot is what you’ll measure growth against.
  2. Map the whole landscape first, wiring included, before any deep dive.
  3. Write the abstract — what is this, how is it different from its neighbors?
  4. Find where it touches what you already know — the hooks that make it matter now.
  5. Curate resources in accessibility order — papers last.
  6. Sketch a real arc, then keep it loose — don’t over-condition the timing.
  7. Keep a running “design & flow” log — the trail of how your map redrew itself is the most valuable artifact, and the blog basically writes itself from it.

That last point is literally what you’re reading. The full workspace — landscape, the fifteen weekly units, the curated resources, and the evolving log — is open here: github.com/prabakaranc98/personal-curriculum.

I’m going to walk it one tiny experiment at a time, and let it evolve. If you build one for your own curiosity, I’d genuinely love to see it.

Written by thinking out loud with an AI partner — not to be handed the answers, but to argue with the map, catch myself over-planning, and stay honest about the difference between feeling like I learned something and actually being able to use it.