Build log · 2026
Make any quiz with AI in 30 seconds — and the three attempts it took to ship it.
How I added AI quiz generation to a side project without paying for every user's tokens — two ideas that failed, one that survived, and a JSON parser that forgives a lot.
The sleepover
It was a Saturday afternoon. My son had friends coming over for a sleepover that night, and he wanted to host a quiz. I'd said I'd help him build one. I'd also told my partner I'd finish something else by 5pm.
The two promises were not compatible. (A typical excuse, I know.)
I sat down at the laptop and thought: just ask the AI. I opened ChatGPT and typed:
Create a 10 question quiz for 8 year old kids with a Minecraft theme. Only expert Minecraft players should get 100%. Make it tough.
Twenty seconds later I had a quiz. My son was reading the questions over my shoulder, suspicious.
"But but but but daddy — how will the AI know what I want?"
He was eight, and he was already asking the question every product manager eventually asks: who is in charge of the requirements here?
I showed him the prompt. I changed "Minecraft" to "Pokemon" and re-ran it. He watched a new quiz appear. He didn't say anything, but he tilted his head in the way he does when he's reconsidering whether something is magic.
That was the moment I thought: this should be a feature in Quizzy.
The cost wall
The naive version is two afternoons of work. Slap a form on a page, send the user's input to an LLM, render the result.
The problem is the bill.
If I put my OpenAI key behind every user, I am paying for every quiz on Quizzy.earth. The economics of a free product where every action calls a paid API are bad in a predictable way: the more successful you are, the more it costs you. There's no version of "this took off" that isn't also "I am broke."
Quizzy doesn't charge for this. I don't want it to. So the question wasn't how do I add AI? — it was how do I add AI in a way where the user's AI does the work?
That turned out to be the hard part. I tried three things.
Attempt 1: The BYO-AI form
The first idea was the obvious one. Build a small form: topic, difficulty, language. Press a button. The app composes a prompt you can copy.
You paste that prompt into whichever AI you already use. ChatGPT, Claude, Gemini, whatever. The AI spits out JSON. You paste the JSON back into Quizzy. The app parses it into a quiz.
In theory: elegant. The user pays for their own tokens. I pay for nothing. Everyone wins.
In practice: I was the only person on Earth who could use it.
The first problem was that most people don't know what JSON is. I'd built a flow that required users to understand a serialisation format, and most of them weren't going to. I figured I could explain that part.
The second problem was the one I didn't see coming, and my son was the one who found it.
I handed him the laptop to try it. He typed his topic into Quizzy, copied the generated prompt, pasted it into ChatGPT — and the moment the AI started typing, he selected the half-written response and pasted it back into Quizzy. He didn't wait for the stream to finish. Why would he? On every other app he uses, when text appears, it's done. He pasted half a JSON object, hit create quiz, and got an error.
He looked up at me. What did I do wrong?
He hadn't done anything wrong. The product had. If an eight-year-old can't build a quiz with this thing in under a minute, the product has failed — that was the rule I'd written down for Quizzy on day one, and I'd just watched it break in front of me. Even a kid should be able to build a quiz without friction.
I'd built a feature for developers and shipped it to families.
Attempt 2: The magical disappear
The next idea was genuinely fun to think about.
What if the AI itself sent the quiz back to me?
The flow in my head:
- The user gets a prompt with a unique ID baked into it.
- They paste it into their AI.
- The AI generates the quiz and
POSTs the JSON to/api/generate-quizalong with that ID. - My backend stores it in Redis under that ID.
- The frontend has been polling (or sitting on a websocket) the whole time. The moment the ID lights up, the quiz appears.
The user does nothing. They paste a prompt, they watch their AI think for a few seconds, they look back at Quizzy and the quiz is just there. No copy. No paste. No JSON.
This would have been magic.
It didn't work because, as it turns out, most AI agents won't POST to an arbitrary URL. Some block it outright. Some require a tool the user hasn't enabled. Some quietly refuse. The version of this that works in 2026 is not the version of this that works for a stranger using whichever AI they happen to have open.
Maybe one day. Not yet.
Attempt 3: The URL smuggle
If POST is forbidden, what about GET?
Most AI agents will "browse" or "search" a URL when asked. So what if the prompt told the AI to construct a URL where the entire generated quiz lived in the query string, and then to visit it? My server would parse the quiz out of the query params, stash it in Redis, same as before.
I built this one. It almost worked.
It died for two unromantic reasons. The first is that browsers and proxies cap URL lengths somewhere between 2k and 8k characters. A ten-question quiz with four options each blows past that without breaking a sweat. The second is that the AI's built-in browser tools have their own opinions about what counts as a legal URL, and a 6k-character query string was not one of them. The requests never landed. The DNS resolved to nowhere useful. I was smuggling air.
So: I couldn't hide JSON. I couldn't avoid the copy-paste. And on mobile — where most of Quizzy's traffic actually lives — every paste also means switching apps. Open Quizzy, copy prompt, swipe to ChatGPT, paste, wait, copy response, swipe back, paste again. App-switching on a phone is its own friction tax, and unlike the others, this one I couldn't engineer my way out of in this version. The user's AI is in a different app from mine, and the path between them runs through the OS.
So the remaining question was a smaller one: with all of that fixed in place, could the existing flow at least stop being a UX punishment?
Users don't want your product. They want the thing your product gives them. Every step you can absorb so they don't have to think about it is the product.
What I actually shipped
I couldn't remove the copy-paste step. But I could make it forgive almost anything. Two changes did most of the work.
JSONL instead of JSON. Instead of asking the AI for one big JSON array, I ask it to emit one JSON object per line. Now if a user pastes a partial stream — three lines out of ten — I get a three-question quiz instead of an error. Their copy is imperfect; the parse is graceful. The quiz that appears is a little shorter than they expected, not a red banner.
jsonrepair for everything else. Users don't just paste the JSON. They paste the AI's whole response — including "Sure! Here's your quiz:" at the top and "Let me know if you want me to tweak anything!" at the bottom. The jsonrepair package is forgiving in exactly the ways an LLM's output is messy. It strips chatter, closes unclosed brackets, repairs trailing commas, fixes single quotes. It turns "almost JSON" into JSON.
jsonrepair is for: the paste that includes the AI's polite preamble and the cheerful sign-off.Together: the flow still has a paste step, but the paste step almost never fails. The user sees a quiz appear. They don't see the parser stitching their messy paste back into shape.
It's not the magical disappearing-prompt flow I wanted in attempt two. But it ships, it costs me nothing per quiz, and it works for grandparents pasting from ChatGPT on a Sunday morning.
The thread
Every dead end I hit was a version of the same instinct: let the user's tools do the work. That instinct was right. The trick wasn't backing away from it — it was accepting that the rough edges of "the user's tools" (partial pastes, friendly preambles, half-streamed responses) were my problem to absorb, not theirs.
Good UX, in this case, looked less like a clever pipeline and more like a tolerant parser. The clever architecture would have been more satisfying to build. It also wouldn't have shipped.
What I learned shipping AI on a side-project budget
Three things I'd tell someone trying this next.
Let your users' AI do the work.
If your side project is free, every paid API call comes out of your pocket. The instinct to push the LLM call onto the user's own ChatGPT or Claude was right. The hard part wasn't finding a way around that instinct — it was making the path bearable.
Absorb the mess. Don't punish the input.
Users paste mid-stream. They paste the AI's preamble. They paste single quotes and trailing commas. JSONL plus a lenient repair pass turned a flow that errored on every fourth paste into one that almost never errors at all.
The clever architecture doesn't matter if it doesn't ship.
The magical disappearing-prompt flow was the better product on paper. It also didn't work for the AIs people actually use. A tolerant parser is less satisfying to build than a brilliant pipeline — and infinitely more useful than one that's broken in production.
Make a quiz with AI. Thirty seconds, your tokens.
No sign-ups. No API key required from you or me. Pick a topic, paste the prompt into your favourite AI, paste the response back.