Learning workflow · desktop automation · personal tooling
Copying a page into a notebook is the slowest way to learn it, and I did it for about two weeks before I stopped. The course is already software. The material, the quizzes, the progress bar, all of it. So the studying should be too. What I use instead reads the page I'm on by itself, with nothing to paste or screenshot, says it back shorter and in plainer words, and lets me stop and ask it anything the moment I'm confused, like turning to someone sitting next to me who already knows the whole subject. Then it banks a question from the passage and quizzes me a week later, once I've started to forget. Unlike a chat window, it remembers: what I've covered, when I last saw it, and the specific things I keep getting wrong.
The course, the provider and the subject are deliberately left out, and none of my real study material is published. The walkthrough below replays the real loop with the course material swapped for a neutral sample page.
Built August 2026 · self-directed
Why I stopped writing notes
Writing something down word for word feels like studying. It mostly isn't. You end up with a transcript you'll never reread, and the hour went into transcription instead of into understanding. What I wanted was the opposite trade: read the page once, get it back in fewer and simpler words, and then spend the time on being tested, because getting a question wrong is the only part of this that reliably teaches me anything.
I actually stopped and asked it outright, partway through a chapter, whether physically writing things down was helping me memorize anything or whether I should just keep going the way I was. That conversation is why the notebook went away. There's a line in my progress file from the same day: "Stopped hand-writing notes this session (deliberate)." Everything here exists to make that a good decision instead of a lazy one.
The loop
The last three only work because something remembers between sessions. That is the part that makes this a system instead of a habit, and it is the next section.
Nothing to paste
The setup most people end up with is screenshot the page, paste it in, type out what you want, read the reply, go back. That's a second job running alongside the one you're trying to do, and it's why most people try studying this way once and quit.
Mine watches the same page I'm reading. I click Next and it goes on its own. I never tell it I've moved, never paste anything, never take a screenshot. The material doesn't have to be re-fed because it's already looking at it.
The piece that does this is a small PowerShell watcher built on Windows UI Automation. It finds the right browser window by reading the omnibox, then pulls the page's text straight out of Chrome's accessibility tree. No screenshot, no OCR, no clipboard, and nothing for me to trigger. Read-only isn't a promise in a prompt here, it's a property of the mechanism: the script has no code path that clicks, types, opens a tab, or takes focus.
Most of its length is the unglamorous part. The course is a single-page app, so the text arrives after the URL does, and it polls until the page has read the same twice before believing it. It re-checks the URL afterwards in case I clicked ahead while it was waiting. If a read comes back looking like the page I was already on, it treats it as a glitch and keeps waiting rather than summarizing the same page twice. And it classifies the URL as material, question, or section-complete, so it knows to stay quiet on a quiz page instead of helpfully spoiling the answer.
That sounds like a small convenience and it isn't. Every one of those hand-offs pulls your attention off the content and onto the logistics of moving text between two windows. You only get to concentrate on one thing, and I want that thing to be the material. The first version polled on a 60-second timer and was somehow worse than nothing, because it either summarized a page I'd already left or made me sit and wait on it. Firing when I turn the page is the only cadence that disappears.
An expert sitting next to you
Studying alone, when you hit a sentence that won't parse, you get three bad options. Reread it five times. Skip it and hope it isn't on the test. Or go searching and lose twenty minutes to someone else's blog. All three are why self-paced courses have the completion rates they do.
Now I just ask. Mid-page, mid-sentence, at 1am. It already knows the subject cold, so there's no wait and no sense that I'm burning someone's patience on a question I probably should already know. That last part matters more than I expected. Six weeks into a course I asked it what a very basic term in the material even meant, something I'd have been too embarrassed to ask a classmate. It answered and we moved on. On my own I'd have nodded along and stayed confused.
And when an explanation doesn't land, I say so and get a different one. A book has exactly one way of phrasing each idea, and if that phrasing doesn't fit your head, you're stuck with it forever. Here I can say that didn't help, give me the version with a worked example, or ask for it laid out as a table because I'd follow it better that way, and it just does that. Sometimes I ask it to build a small interactive thing to show me a concept I can't hold in my head from text. That's not something a textbook can do at any price.
The best stretch in my logs is about ten questions in a row on one stubborn topic. I say I don't understand it. I try restating it in my own words and ask if I've got it right. I get told I'm close and where I'm off. I push back that the follow-up question feels circular. I ask about an edge case, then invent a scenario and ask what happens in it. Then I ask what the single principle underneath all the exceptions is, and admit I don't know. Two messages later I write: "I think I understand. It never blocks the government, and it never blocks anything you specifically signed for." That sentence is mine, and it's worth more than any page of copied notes.
The other thing it caught: two chapters of the material genuinely contradicted each other about an exception. Studying alone I'd have picked whichever I read last, moved on, and got it wrong on the exam without ever knowing why. Instead we went and found the passage that settled it, and the resolution went in the tracker.
It can also be confidently wrong, and that's the whole reason for the rule below. Nothing gets banked as a question unless it traces back to the passage on screen. An expert next to you is only worth having if you can check them.
It remembers, which is the whole difference
Everything above this point you could roughly approximate by pasting a page into a chat window. The reason I'd call this a system rather than a habit is that it doesn't start from zero every time I open it.
Chat is amnesiac by design. Close the window and everything it knew about what you'd covered, what you'd already been tested on, and what you got wrong goes with it. Fine for a one-off question. Useless across a twelve-week course, because the two things I actually want a computer for here are what have I forgotten and what did I get wrong last time, and both of those are questions about the past.
So the state lives in files instead. progress.md holds where I am and a table of when each chapter was first learned and last quizzed. That table is the input to the only scheduling decision the thing makes: what's due. A chapter I was tested on today isn't worth re-testing tomorrow. One I learned three weeks ago and haven't touched since is. question-bank.json holds the questions, 58 of them across 29 topics, each tied to the chapter it came from and flagged if it's one of the ones that bites.
Then the part I didn't expect to matter most: known weak spots. It doesn't log that I got a question wrong. It logs the bad assumption that produced the wrong answer. One of mine reads, in effect: I ranked two competing claims by date, when one of them doesn't compete on date at all. "3/4" tells me nothing I can act on. A named misconception tells the next quiz exactly what to contain.
That file also holds resolved contradictions. Two chapters of the material genuinely disagreed with each other about an exception, and a third passage settled it. Rather than sort it out in my head and forget, the finding and the reasoning went in the file, so the next quiz is built on the right reading and I don't relitigate it with myself a month later.
The bit that compounds is that this gets more useful the longer I go. Generic study advice knows what people in general forget. This knows what I forget, and it's a growing map of the specific places my understanding of the material is wrong.
The generator
A 159-line Node script takes a question bank, a title, and a list of question ids, and writes one self-contained HTML file. No build step, no framework, no network call, nothing to install. It opens anywhere and it works, which matters because I wanted to be able to take a quiz on my phone without standing up a server for it.
It refuses to run if any id is missing and prints exactly which ones, so a typo fails loudly instead of quietly handing me a shorter quiz and letting me think I covered the chapter.
The quiz itself shows one question at a time, reveals the explanation the moment I answer, and ends on a review of only the ones I missed, plus a retake. It escapes what it interpolates, follows light and dark, and keeps visible focus rings so it's usable from the keyboard.
The sample quiz is this generator’s real output, unmodified, run against a bank of web-fundamentals questions I wrote for this page. My own bank stays private.
The bank, and the one rule it has
Questions live in one JSON file. Each carries an id, its chapter, a topic, the question, the options, the correct index, and a short explanation. Mine currently holds 58 questions across 29 topics, and the explanations average about 110 characters, because a paragraph of justification is just the notebook again.
The rule that matters: nothing is invented. Every question has to come from text the course actually served, and the explanation is the receipt. If it can't be written from the passage, the question doesn't go in. A study tool built with an AI assistant is one careless prompt away from confidently testing me on a rule that doesn't exist, and a wrong question is worse than no question, because I'd learn it.
The other field earning its place is trap. It flags anything testing an exception, or one of a pair that's easy to mix up, so review can weight them heavier. 28 of my 58 are flagged, which tells you where the difficulty in this material actually lives.
Decisions I had to make
Why this is on a software portfolio
It's my favorite thing I've made, and it's the one I actually use the most, by a distance. That's a strange thing to say about something with no installer and no UI of its own. But it's the clearest project I have where I was the user, so there was nowhere to hide behind a nice screenshot: either it saved me time this week or it didn't.
It's also a small version of what I want to do professionally. Watch a process someone does by hand, work out which part is worth automating, and build only that. I automated the transcribing and the remembering. I deliberately left the arguing and the getting-it-wrong alone, because that's where the learning actually happens.
The story · STAR
Situation
I was working through a long self-paced online course and hand-writing notes off the screen, which ate the study time and taught me very little. The built-in review didn't remember anything I'd previously got wrong.
Task
Replace transcription with something that reads the page, restates it in plainer and fewer words, answers questions about it live while I'm still looking at it, and then actively tests me on it later. All without becoming a tool that invents material or takes over my browser.
Action
Designed the loop and built the parts that needed to persist. Modeled the material as a structured JSON bank with a strict no-invented-content rule and a flag for exception-type questions. Wrote a dependency-free Node generator that emits a self-contained, accessible, theme-aware quiz from any set of question ids and fails loudly on unknown ones. Kept a markdown tracker of last-quizzed dates and named misconceptions to drive what gets tested next. Constrained the reading step to read-only, triggered on my own page turns, with model choice matched to how hard the page is.
Result
58 banked questions across 29 topics, 28 of them flagged as the confusable ones, and a study loop I use daily in place of writing notes. Quizzes that used to take a custom prompt each time are now one command. Two things changed measurably: topics I'd have skimmed past and quietly not understood now get chased down in the moment, because asking costs nothing. And because the state sits in files rather than a chat window, the weak-spot list keeps growing into a map of the specific places I'm wrong, which is the part that gets more useful the longer I use it.
Built with
Status & honest limitations
Personal tooling, in daily use. The generator demo above is live and runs the real code.
Self-directed personal tooling, built with AI-assisted development.
Design note
The quiz artifact looks like a paper exam sheet rather than an app. One question a screen, a serif for the question, monospace for anything numeric, one accent color. The explanation appears in place the instant I answer, because the gap between answering and finding out is where the learning happens and every extra click widens it.