DEV Community: Sohee Lee

knowledge-gate: slow and steady, a new AI talk becomes one line in my notes

Sohee Lee — Sat, 24 Oct 2026 21:25:26 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

I learn from AI engineering talks on YouTube, and I keep my own notes on the ideas that matter. The talks win. One channel I follow posted 77 videos in 30 days, 30.6 hours of video, and many of them say the same thing under different names.

knowledge-gate watches the channels for me, slowly and steadily. When a talk is uploaded, a small server turns it into a card: a one-line conclusion, a short summary, and claims, each with a word-for-word quote and the second it was said. The cards grow into one map of concepts, so ten talks about one idea become one page. When I open my laptop, Gemma 4 12B in Ollama reads the new cards next to my notes and appends the points they don't have yet, below what I wrote. The notes themselves stay on the laptop.

So far (evening of October 24): 95 talks on the map, 444 claims, and 397 of their quotes (89%) found word for word in the transcript, ignoring case, punctuation and "uh". Only those are ever shown. This checks that the speaker said it, not that the claim is right.

The Lazy Payoff

Before, a new talk would pop up and I'd think: I'll watch it later. Then I got busy with other things and forgot, and the ones I did watch I had to sum up and copy into my notes by hand. Now that is the server's and the laptop's job.

I used it this week. On October 21 the server took five uploads from push notifications without me: four became cards, and one narrated in Korean was skipped on purpose. On October 24 it happened again with an Arize AI talk, "Your Agent Fix Just Broke Something Else". Its push notification reached the server at 19:01 UTC, the card was made without me, and that evening the merge put one point into my Agent Harness note: 46 lines became 48, the git diff only adds lines, and the new point links to 05:43 in the talk.

My Note → Agent Harness on the laptop page (127.0.0.1:4321), captured October 25. My working definition and open questions sit above; the highlighted point is the one merged on October 24.

It still works without me, end to end. On October 24 I checked the whole path once more, from a YouTube upload to an answer, without starting anything by hand on the server:

15:00 UTC: the AI Engineer channel uploaded "How Bridgewater Turned 100 Million Documents Into an Edge".
15:01: YouTube's push notification reached the webhook, and the workflow started.
15:04: Temporal marked it completed: 132 transcript lines, a card, 2 new concepts on the map, filed under Memory & Context, all checks passed.
That evening, the laptop's morning step pulled it and added 4 points from this talk (7 from that day's two talks) to my notes, each with its quote. The git check reported my existing text unchanged.
I typed "What is native filtering in vector search?" and the Notes Assistant answered from that talk, with a link to 10:34, the second it was said.
A second talk that evening, whose push notification arrived at 19:01 UTC, went through the server the same way. To check the laptop's scheduled morning task, I started it by hand; it pulled the talk and added 5 points, 2 of them to my own notes (Agent Harness, Code review with agents).

That check also found a bug of mine: four paper cards left over from an earlier experiment had no upload age, and the morning step stopped at the map. It is fixed, and the paper cards are out, because this project is about talks.

What it saves. On October 22 the laptop page held 4 new talks: 1 hour 52 minutes of video, and about 7 minutes to read. The 7 minutes is the page's own estimate at 200 words a minute; I did not time myself. I still choose which talks to watch in full.

Demo

Video: https://youtu.be/3SoKm_N-4lU (2:02)

Code

gracelee087 / knowledge-gate

knowledge-gate: AI talks become checked cards and land in my own notes, by open Gemma models. Answered from my notes.

knowledge-gate

Slow and steady: a small server turns every new AI engineering talk into a checked card, and Gemma 4 on my laptop appends the points my notes don't have yet. The notes themselves stay on the laptop.

The morning page in Chrome at http://127.0.0.1:4321 on my laptop (Oct 24), with the talks that arrived that day.

Demo video (2:02): https://youtu.be/3SoKm_N-4lU

At a glance

What it does	A new AI talk is uploaded → the server turns it into a checked card → every morning my laptop adds only what is new to my own notes → I can ask, by typing or by voice.
Gemma 4	Gemma 4 31B writes the cards and joins concepts on the server; Gemma 4 12B and EmbeddingGemma in Ollama merge my notes and answer on the laptop. The AI agents
Checked by code	A quote is kept only if it is in the

…

View on GitHub

Repository: https://github.com/gracelee087/knowledge-gate (MIT)

How I Built It

A model writes, code checks

My first try was the obvious one: give a small model the tools and let it run the job. Gemma 4 E4B, as a Mastra agent with two tools, called the transcript tool once, never called the notes tool, and then asked me for the video ID it had just used. So no model chooses the steps. The pipeline is one fixed Mastra workflow on Temporal, each model call has one job, and code checks every answer before it is kept.

Every agent is named after its job:

agent	model	job
Card Writer	Gemma 4 31B	writes the card
Quote Checker	none, plain code	keeps a quote only if it is in the transcript word for word
Concept Matcher	Gemma 4 31B + bge-m3	same idea as an earlier talk, or new?
Category Keeper	Gemma 4 31B	files each talk in a section
Rule Tester	Gemma 4 31B	keeps a rule only if runs with it are as good or better
Note Merger	Gemma 4 12B + EmbeddingGemma	adds new points to my notes, on the laptop
Highlighter	Gemma 4 12B	marks key phrases, on the laptop
Notes Assistant	Gemma 4 12B + EmbeddingGemma	answers my questions from the talks and my notes, on the laptop

Gemma 4 31B and bge-m3 run on DigitalOcean's serverless inference. The laptop agents run in Ollama.

Worst-case scenarios while running

While building it, I kept asking one question: what is the worst thing this could do while I sleep? Each answer got a check, and each check has met the real thing.

What if…	What catches it	What happened
a card quotes something the speaker never said?	The Quote Checker keeps a quote only if it is in the transcript word for word.	397 of 444 quotes found (Oct 24); only those are ever shown.
the merge changes or deletes my own words?	The merge only appends. After every merge a git check reports any existing line that was removed or changed. A claim my note already has word for word is marked known before the model is asked.	Oct 24: the Arize AI talk took my Agent Harness note from 46 to 48 lines, and the git diff of that merge only adds lines. Merging the same 4 talks a second time: 23 of 23 known, 0 appended.
the server dies in the middle of a talk?	Temporal: every step has a 5-minute timeout and up to 3 attempts.	I killed the worker during the map step; only that step ran again, with the same result. On Oct 22, for real: the card step timed out once, and Attempt 2 finished it.
two different ideas are merged because they share a word?	Atlas vector search gives 6 candidates, code accepts only an answer that names one, and a second, strict call checks every join.	"AI Factory" (data centers) was pulled out of "Software Factory".
something fails and nobody notices?	Sentry records each failed step as an issue.	LECTURE-GATE-4: the map step failed with `EACCES`, and the laptop had 77 cards while the server had 80.
the laptop's morning step fails quietly?	Task Scheduler records the exit code, and the morning log keeps the error. No alarm on the laptop yet.	Oct 24: my end-to-end check, not an alarm, found that the morning task still ran an old copy of the project and failed (result 1 at 10:09), and that the morning step stopped at the map on four leftover paper cards. Both fixed; the next run ended with result 0.

The one that surprised me. On its first test the Quote Checker rejected 2 of 4 real quotes. The model was not the problem: auto-captions contain "uh"s, and the model had dropped them. Fillers, case and punctuation are now ignored on both sides. A check that is too strict looks safe, but it throws away true quotes.

Two smaller ones were Gemma's own. On one real card it wrote the chapter summaries in Korean; a code check now finds non-English fields and sends the card back with "Translate these fields into English … Change nothing else.", which fixed it 3 times in 3 (making the card again from scratch: 1 in 3). And it borrowed the 4 example concept names from my prompt, 18 times across all cards; after I removed them, the share of concept names in the speaker's own words went from 95% to 99%.

The real vectors in Atlas lecture_gate.mentions: one talk’s 5 concepts, each stored as 1024 numbers from bge-m3 (first 6 shown). The vec index above compares them by cosine.

Measured, not assumed

I picked the card model on a test set of 10 talks (8 to 46 minutes, talks and interviews). With my first prompt, Gemma 4 31B found 90% of its quotes and gpt-oss-120b 71%, at $0.0018 against $0.0021 per card. After that, the prompt changed only when the same test set said so. From v2 to v7, quotes found rose from 88% to 96%. v8, live since October 22, adds the summary and one claim per 5 minutes of talk; quotes found fell to 94.2%.

Could the laptop make the cards itself? On its CPU (no GPU), one card each for two talks:

model in Ollama	quotes found	time per card
Gemma 4 E2B	8/9	3.7–5.6 min
Gemma 4 E4B	10/10	8.0–10.0 min
Gemma 4 12B	8/8	20.4–21.8 min
Gemma 3 4B	1/7	9.7–11.3 min
Qwen3 8B	9/10	19.2–33.7 min

That ranks the models; it proves nothing. Minutes per card is too slow, so cards are made in the cloud and the laptop gets the private job. For that job, E4B handled 17 claims in 86 s against 290 s for 12B, but appended 4 claims my notes already said. A merge that repeats my notes is worse than a slow one, so the Note Merger runs 12B.

Mistakes become rules, and a rule has to earn its place

Every failed check is saved as a lesson. Showing the agent its own past mistakes did not help: the Category Keeper failed all 4 rounds the same way. So the Rule Tester turns lessons into a candidate rule and runs the task with and without it: 3 runs each for a category rule; for a card rule, one first attempt on the talks the lessons came from plus 2 test talks, where at least as many cards must pass and verbatim quotes may drop by no more than 10 points. A rule that does as well or better goes to Backboard, where the prompts read it. Only the rule reaches the model, never the lessons behind it.

"Do not group terms that share a keyword but refer to different functional roles…": broken checks went from [5, 14, 14] to [3, 2, 2], 79% fewer, in one manual run on October 21. Kept.
"Put every lecture in one single category named All Lectures", a bad rule I fed it on purpose: [0, 1, 0] became [1, 1, 1]. Rejected.

On October 22 Backboard held 7 rules. The newest was added that morning: "Do not group terms where one describes a high-level goal or purpose and the other describes a specific technical implementation or process."

Slow and steady: I killed the worker on purpose

To test it, I force-killed the worker 19 seconds into the map step, then started it again. Transcript and card did not run again. The map step's second attempt started about 5 minutes after it was scheduled and finished in 31 s, with the same result as the all-at-once run: "concepts 4/4 same; category same". The price is the wait: @mastra/temporal has no heartbeat option, so Temporal only notices a dead worker when the timeout runs out.

The Mastra workflow definition (src/mastra/index.ts): 5-minute timeout, 3 attempts, and three steps in a fixed order.

The October 22 retry from the table, as Temporal recorded it: the second attempt finished in under 3 minutes, and the whole run in 9, while I was doing something else.

Every call traced, and one real incident

Every model call is a Sentry gen_ai.chat span with the model name, time and token counts. In the first 14 days (to October 22), Sentry recorded 977 model calls, across every model I compared, from Gemma 4 E2B on my laptop to gpt-oss-120b in the cloud. It prices each card call from its tokens (under $0.01), and the output column stays empty: prompts and outputs are never sent.

LECTURE-GATE-4 from the table was my own mistake: I had regenerated the map files as root, but the services run as an unprivileged user. A chown and a re-run as the service user fixed it.

The base is cheap and boring. A $6 DigitalOcean Droplet runs the server and uses 833 of 961 MiB at idle. YouTube blocked scripted transcript fetches from my home and from the Droplet, so transcripts come from SerpApi, cached on disk because the free plan has 250 searches a month.

SerpApi search log: each row is one talk's transcript request (youtube_video_transcript). The top row is the newest talk (Ve2bAarPA2I), October 22, 19:01 UTC. 105 of the month's 250 searches used.

"Apps $1.48" on that bill (October 1–21) is another project of mine on the same account. This project is GenAI Serverless Inference $0.83 + Droplets $0.02.

On my laptop: how the note grows

The Note Merger reads each new claim next to the note it belongs to (EmbeddingGemma finds the note by meaning) and answers "known", "new" or "unrelated". "Known" counts only if the model copies the note sentence that already says it, and code checks that sentence is there. On the laptop page my notes live under My Note in the sidebar.

Points that none of my notes takes go to a note for their section of the map, so each section grows into a note of its own, without repeats. When a talk raises a question, the Notes Assistant answers only from the 8 closest claims and up to 2 notes, citing [C1] or [N1]; a citation that matches no source is not linked, and the page flags it. The page runs on 127.0.0.1 only.

I can also ask by voice, but only if I start the page with --stt whisper; it is off by default. Whisper runs on the laptop, but in my tests it heard "agent hardness" for "agent harness" and "head fund" for "hedge fund", and then my notes had no answer. Typing is slower (the 12B answer above took about 4 minutes on my CPU) but it hears me right.

The demo's narration was made with ElevenLabs (voice "Lara"). Only the narration script was sent. The page also has an ElevenLabs demo mode that reads answers aloud; then the answer text goes to ElevenLabs, and the page says so in its header. By default it uses the browser's own voices.

Limitations, and what I want to try next

Most comparisons are small: at most 3 runs per side, and the local-model table is one run on two talks. The Rule Tester keeps a rule on "no harm", not on proven help.
The Notes Assistant's conclusion can change between runs. The sources it shows are real; the conclusion is not stable.
My notes in these tests are four sample notes, and the map covers English talks only. I did not measure how long reading the cards takes me, so I claim no hours saved.

What I want to try next, to catch more errors and make it faster: more harness (a code check behind every model decision, which also skips a model call that takes minutes on my CPU), more nightly Rule Tester runs so a rule is kept on measured help and not only "no harm", the same test set for the laptop agents with more runs per model, and a cost comparison of cloud against laptop, per agent.

Why Does Open Innovation Matter?

Open worked better here because of my notes. A hosted model would need my notes on someone else's server. With open weights, the model that reads them runs on my laptop, and after the morning pull from Atlas, the merge, the highlights and every answer come from Gemma in Ollama on 127.0.0.1.

Open models work for me while I sleep. Talks arrive at any hour; the server turns them into cards, and every night the Rule Tester checks its new rules, without me. Nothing in that loop is specific to lectures: the same watch, check and merge could follow other sources I learn from.

My notes stay mine. They are not only about lectures: they hold what I study on my own, my schedule, and the questions I haven't figured out yet, my own map of what I know and what I don't. Only public talks go to the cloud, where they become the shared concept map below.

The concept map from public talks, at 72 lectures. Each dot is a concept, a line joins two concepts named in the same lecture, and the largest dot, Agent Harness, spans 11 lectures.

I learn from my own collection. Because the notes and the cards sit on my laptop, I can ask the Notes Assistant right away in the chat, and it answers from the talks and my notes, citing both. Asking and reading the sources is how I build up the core ideas.

The same family, in two places. Open weights let me split the work: Gemma 4 31B in the cloud for public talks, Gemma 4 12B on my CPU for private notes. Each was chosen by the measurements above. The cloud side cost $0.85 from October 1 to 21, so it runs every day without rationing.

Where a closed model might be better: a large hosted model might write smoother cards with fewer retries. It would still need the same checks.

Prize Categories

Best Use of Gemma: Gemma 4 31B writes cards, matches concepts, files talks and tests rules; Gemma 4 12B and EmbeddingGemma merge, highlight and answer on my laptop.
Best Use of DigitalOcean: serverless Gemma 4 31B and bge-m3, and the $6 Droplet that runs the whole server.
Best Use of Mastra: one fixed three-step workflow instead of an agent choosing its own steps.
Best Use of Temporal: the workflow survived a killed worker, and only the killed step ran again; in production it retried a timed-out card step by itself.
Best Use of MongoDB Atlas: vector search gives the 6 candidates for every new concept, and Atlas carries public cards down to the laptop.
Best Use of Sentry Agent Tracing: every model call traced with time and tokens, no prompt or output; it caught incident LECTURE-GATE-4.
Best Use of Backboard: it holds only rules that matched or beat their own baseline.
Best Use of SerpApi: the transcript and chapter list behind every card, cached so no search is spent twice.
Best Use of ElevenLabs: narration for my demo video, and an opt-in demo mode that reads the morning briefing and answers aloud.

Farm Post: One Photo, and You're Selling

Sohee Lee — Sat, 17 Oct 2026 21:58:40 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

This started with my grandmother. She grows peanuts and corn and sells them at the local market. But big supermarket chains have moved into rural areas too, and there is less and less room for sellers like her. She has never thought about selling online, because she doesn't know how to use the devices and apps it takes.

That's where the idea came from: something that lets her, and the people in her rural area, buy and sell easily, with as few steps as possible. Taking a photo and tapping a few buttons should be enough. Farm Post is built for people like her: people who know their harvest, not marketing.

Farm Post is a Telegram bot for small farms that already sell directly to their customers: a farm shop, a market stall, a family with a field of persimmons.

The farmer takes one photo and sends it to the bot. That's the only thing they have to do.

Gemma 4 reads the photo and writes the whole post: a title, a short warm description and hashtags.
Live online prices for similar products appear next to the question "How much?", so the farmer has a reference. They tap a price, a unit (per kg, per piece, per jar…) and how many they have.
Four ready-to-post designs are drawn from the farmer's real photo (banner, chalkboard, polaroid, magazine). No AI-generated images: what customers see is what they pick up.
One more tap and the post is live in the farm's Telegram channel, with the date, a listing number and a 🛒 Reserve button.
A customer taps Reserve and chooses how many. Stock goes down by itself, the post updates, and the farmer gets a message. They pay at pickup.

No website, no shop builder, no agency.

Who would pay for it?

I didn't want to guess, so I looked for research on farms that sell direct. A 2025 survey of 208 agricultural direct marketers in Germany found:

"a considerable proportion of farmers are still reluctant to actively use these channels. The most frequently cited barriers are lack of time, and technical expertise, as well as uncertainties regarding the creation and planning of content."
— When will I be successful? The use of social media in agricultural direct marketing in Germany, Agricultural and Food Economics 13, 23 (2025)

Farm Post is built around exactly those three barriers:

Barrier from the study	Farm Post
No time	One photo, then taps. No typing.
No technical skills	It's just Telegram. No website to build.
Not sure what to post	Gemma writes the text, and you pick one of four designs.

I'm building for two kinds of sellers. Some, like my grandmother, have never sold online and wouldn't know where to start. Others already have customers, but take orders by phone, one call at a time. Farm Post gives both a simple way to post what they have today and let customers reserve it. That's who I think would pay.

Demo

https://youtu.be/Ahk6svVCpEQ (1:39, English narration and captions)

Live demo channel: https://t.me/demofarmshop_lee (open it in Telegram and tap 🛒 Reserve under a post to try the customer side)

The video uses screenshots from a real run on 17 October 2026:

Gemma 4 (gemma-4-26b-a4b-it) wrote the persimmon post in 38 seconds.
The market line read: Online shops (DE) sell "fresh persimmon fruit" for €1.19 to €118.28, typical €15.95 (23 offers).
The post went to the channel with a Reserve button, and the reservation reached the farmer's chat.

The four designs the bot made from that one persimmon photo:

Code

gracelee087 / farm-post

One photo → a sales post in a farm's Telegram channel, with a Reserve button. Gemma 4 writes it, SerpApi shows market prices, runs on Render.

Farm Post

One photo → a finished sales post in the farm's Telegram channel, with a Reserve button For small rural sellers (one person or a family): vegetables, fruit, eggs, honey, jam, hand-knitted goods.

Built for the DEV Hacktoberfest Open-Source AI Challenge, Week 2 "Side Hustle".

Demo video: https://youtu.be/Ahk6svVCpEQ · Demo channel: https://t.me/demofarmshop_lee

How it works

The seller sends a photo to the Farm Post bot on Telegram.
Gemma 4 reads the photo and writes the title, text, tags and a search query (generate.py).
Online prices for that query (SerpApi, via price-proxy/) are shown; the seller taps a price, unit and stock.
Four designs are drawn from the real photo (design.py); the seller picks one and taps Post.
Customers tap 🛒 Reserve under the post, choose an amount, and pay at pickup. Stock goes down and the seller gets a message.

The writing rules live…

View on GitHub

File	What it does
`bot.py`	The Telegram bot: photo → price → unit → stock → design → post → reservations
`generate.py`	Gemma 4 through the Gemini API, or local Ollama when no API key is set
`skills/farm-post/SKILL.md`	The writing rules Gemma follows, in the open Agent Skills format
`design.py`	Four designs from the real photo (Pillow)
`price-proxy/`	A small server on Render that keeps the SerpApi key private

How I Built It

Farmer's phone (Telegram)
  photo ──► bot.py
              ├─► Gemma 4 (open weights) reads the photo + SKILL.md rules
              │      → title, description, hashtags, a 2-4 word search query
              ├─► price-proxy on Render ─► SerpApi Google Shopping
              │      → lowest / typical / highest price, number of offers
              ├─► farmer taps price, unit, stock
              ├─► design.py → 4 designs from the real photo
              └─► Telegram channel post + 🛒 Reserve button
Customer taps Reserve → picks an amount → stock updates → farmer is notified

Gemma 4 is the core. It's the only AI step, and it does the part farmers find hardest: looking at a photo and turning it into a post. I use Gemma 4 26B (gemma-4-26b-a4b-it) through Google's Gemini API, and fall back to the 31B model if the API is busy. The prompt asks for strict JSON (item, title, body, tags, search query), so the bot can use every field directly.

The rules live in a plain file anyone can edit. What makes a good farm post is written down in SKILL.md: the title is the product plus one thing you can actually see, the body is 3–5 friendly sentences ending with "Send me a message to reserve yours", and the model must never invent prices, weights, origins or "organic". The bot reads those rules straight from the file. A farmer (or anyone) can change how posts are written without touching code.

Prices are never made up. The farmer taps the price. Gemma only writes a search query, and SerpApi looks up what online shops charge. The bot always says it's "only a rough guide for a farm or market stall".

SerpApi + Render. SerpApi gives the bot live Google Shopping results. The key must not sit in the bot, so a 185-line Python server (standard library only) on Render's free plan holds it. It caches each query for an hour and stops at 200 lookups a day so a free key can't be drained. The bot itself also runs on Render as a web service in webhook mode, defined in the same Blueprint (price-proxy/render.yaml).

Honest limits

Writing a post takes about 30–40 seconds on Google's free tier (measured: 30 s and 38 s for the persimmon, 23–54 s in other tests).
Online-shop prices are noisy. In one persimmon search in Germany the results also included seeds and young trees, which is why ranges can be so wide.
Render's free plan sleeps when idle, so the first price lookup after a break can be slow. The bot retries.
The demo video was recorded while the bot ran on my laptop. It now runs on Render. Reservations have only been tested from my own account so far.
Google's free tier for the Gemini API may use the data to improve Google's products. A farmer who doesn't want that can run Gemma locally instead (see below).

Why Does Open Innovation Matter?

Because the farmer shouldn't be locked in.

Gemma 4's weights are open (Apache 2.0). Today Farm Post calls Gemma through Google's free API because that's the cheapest way to start. But if that ever changes, gets too expensive, or a farmer doesn't want their photos on someone else's server, the same model runs on their own computer: without an API key, generate.py switches to Gemma 4 through Ollama. Nothing else changes. With a closed model, the business would depend on one company's price list and terms.

Open weights also let me test models myself instead of trusting a model card. On my laptop (CPU only, no GPU), I ran the same three farm photos (potatoes, eggs, apples) through two open models, once each. Gemma 4 e4b took 71 seconds in total and Gemma 3 4B took 100 seconds. Both named all three products, but Gemma 3 added details that weren't in the photo, like "happy hens" and "German eggs". So the local fallback uses Gemma 4.

The same goes for the rules. They're in an open Agent Skills file, not hidden in a prompt on a server. Farmers know their products better than I do, and they can fix the wording themselves.

What's Next

A customer-service agent. It would answer simple questions from the listing data (name, price, stock) and pass everything else to the farmer. It's not built yet. It needs pickup times and an address first, so it never makes up an answer.
Run the bot on Render full-time and test reservations with real customers.
Payments. Today customers pay at pickup. Later I'm thinking about connecting online payments and customer support, and turning Farm Post into a full product.

Prize Categories

Best Use of Gemma: Gemma 4 (gemma-4-26b-a4b-it) reads every photo and returns one strict JSON with five fields (item, title, body, tags, search query). The persimmon post took 38 seconds. Without an API key, the same flow runs on gemma4:e4b through Ollama on a laptop.
Best Use of SerpApi: Google Shopping results sit next to the price question, so the farmer sees what real shops charge and the model never makes up a price. Gemma only writes a 2–4 word search query. For the persimmon: 23 offers, €1.19 to €118.28, typical €15.95.
Best Use of Render: one Blueprint (price-proxy/render.yaml) defines two web services: the Telegram bot in webhook mode, and a 185-line price server that keeps the SerpApi key private, caches each query for an hour and stops at 200 lookups a day.

Footnotes: your walk, as a beat

Sohee Lee — Sun, 11 Oct 2026 17:51:56 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.

Most of us walk the same streets every day and stop hearing them. Footsteps, traffic, a door, a dog two houses down: it all becomes background. I wanted a reason to listen again, and a way to bring a walk home as something you would actually play twice.

What I Built

Footnotes turns a walk into a beat.

Press Record a walk and go outside. The phone listens while you walk. When you come home, the real sounds you passed become a 30-second beat, on a rhythm measured from the walk itself. Then you hear that beat as three beatboxes side by side, while a pair of neon lips beatboxes along.

Other apps tell you what you heard outside. Footnotes makes music out of it. And it only works if you go out: the screen is just where the walk comes back to you. A trip to the shop is enough; you do not need birds or a view.

Demo

Live app (Android Chrome): https://gracelee087.github.io/footnotes/

No walk at hand? The home screen has two short samples. Their sounds are AI-generated with ElevenLabs (labelled in the app), and their Gemma 4 beat and beatboxes are saved, so trying them costs nothing.

Taking it outside

I tested Footnotes for two days, on walks and on my way to school, with the phone in my pocket.

Every step became fun. Knowing the walk would come back as a beat, I started listening on purpose, and every small sound felt worth keeping. My senses woke up on a route I thought I already knew.

Code

gracelee087 / footnotes

Your walk, as a beat. YAMNet listens on the phone, Gemma 4 makes the beat, ElevenLabs beatboxes it, DigitalOcean runs the server.

Footnotes

Your walk, as a beat. Record the street, and Footnotes turns the real sounds you brought home into a 30-second beat, then into three beatboxes, while neon lips beatbox along.

Live app (Android Chrome): https://gracelee087.github.io/footnotes/
Demo video: https://www.youtube.com/watch?v=rgViikcZVBI

Built for the Hacktoberfest Open-Source AI Challenge, Week 1: Touch Grass (repository started 6 October 2026).

How it works

Record. Tap Record a walk and go outside. The open model YAMNet listens on the phone and keeps one real snippet of each sound it hears (footsteps, cars, water, dogs…). The recording never leaves the phone.
Compress. The app measures the walk's own rhythm (tempo, loud and soft hits on a 16-step bar). Gemma 4 names the walk and makes the beat: which real snippets play it and the rhythm, with a one-line reason on the beat card. Recorded speech is never used as a beat sound.
Beatbox. The same beat as…

View on GitHub

How I Built It

Three steps, all automatic: Record → Compress → Beatbox.

1. Listen, on the phone. The browser records the microphone with voice processing turned off, so the street sounds like the street. At the same time the open model YAMNet, running in the browser through MediaPipe, recognises the sound every half second. I mapped its classes into 46 everyday sound types (footsteps, doors, dogs, water, bike bells…), and for each type the app keeps one real snippet. The recording never leaves the phone.

2. Compress, with Gemma 4. The app finds where the walk hit hard or soft and folds those hits onto one 16-step bar: the hardest become kicks, then snares, then hi-hats. Gemma 4 names the walk and makes the beat: it picks which real snippets play it, and the beat card shows why, for example "Gemma: Steady steps provide a pulse while splashing water offers a calm contrast." Speech is never used as a beat sound.

3. Beatbox, three ways.

Human mouth: every hit replayed by a real recorded mouth sound. No generative AI.
ElevenLabs Clean and ElevenLabs Deep: ElevenLabs Music, given only numbers: tempo, length and which steps carry the kick, snare and hi-hat.
Surprise mix: the mouth takes cut and remixed on the beat grid.

Each card shows a Rhythm match and a Loud/soft match, so you can hear and see how closely each beatbox follows your walk.

The lips are real. I traced a human beatboxer frame by frame with MediaPipe Face Landmarker. Only the points ship, no video. On each hit the lips replay a real kick, snare or hi-hat.

The partners

Gemma 4 (gemma-4-26b-a4b-it, via the Gemini API): names every walk (a short title and one line) and makes its beat: it picks 2 to 4 of the real snippets, a rhythm style for walks without a clear rhythm, and writes the one-line reason on the beat card. It sees only sound names and counts, never audio.
ElevenLabs: three features. Music API makes the two AI beatboxes from the walk's numbers only: Clean with a composition plan, Deep with a prompt. Sound Effects made the sounds of the two sample walks. Text to Speech narrates the demo video.
DigitalOcean App Platform: one small Node server, deployed from the GitHub repo. It holds the Gemini and ElevenLabs keys so the phone never does, accepts requests only from the app's page, runs every Gemma 4 and ElevenLabs call, and keeps a shared daily cap (the home screen shows how many walks are left today).

Open source used

Piece	Role	License
YAMNet	Recognises sounds on the phone	Apache-2.0
MediaPipe Tasks Audio	Runs YAMNet in the browser	Apache-2.0
MediaPipe Face Landmarker	Traced the lip motion (offline, once)	Apache-2.0
Gemma 4	Names the walk and makes the beat	Gemma license (open weights)
Mouth sounds by giddster and ipaghost (Freesound)	The human-mouth beatbox	CC0
Spencer X, One Beatboxer, 20 Beatbox Snares	Source of the lip motion	CC BY 3.0
Footnotes	Everything else	MIT

Why Does Open Innovation Matter?

Because the recording stays in your pocket. A walk recording is private: it catches voices, your street, your routine. An open model small enough to run in the browser means the listening happens on the phone, and only numbers leave it. A closed audio API would need the whole recording just to tell you a dog barked.

Because it is checkable. The rhythm, the snippets and the match scores are plain code anyone can read and change. The open core (YAMNet, the beat, the human-mouth beatbox, the lips) works without an account.

To be honest about the rest: ElevenLabs is a paid closed service, and Gemma runs through Google's API rather than on the phone.

My Agent Session

I built Footnotes in one week with Claude Code as my coding agent. The repo is the record: 42 commits between Oct 5 and Oct 11, 36 of them co-authored with Claude.

The commit history shows how the idea changed along the way:

Day 1: a walk became a written score, with each kind of sound mapped to an instrument, then a short beat made from the real snippets.
Day 2: beatboxes arrived to perform the beat, and the neon lips were traced from a real beatboxer.
Day 3: Gemma 4 started naming each walk, and the server moved to DigitalOcean.
Final days: Gemma 4 began picking the beat's sounds and rhythm, and I removed a remix feature ("Drop it, Gemma!") that the app no longer used.

I brought the idea and tested it on real walks; Claude Code and I wrote the code together.

Prize Categories

Best Use of Gemma: Gemma 4 names every walk and makes its beat, with a one-line reason on the beat card.
Best Use of DigitalOcean: the server on App Platform holds the keys and runs every Gemma 4 and ElevenLabs call.
Best Use of ElevenLabs: two AI beatboxes, the sample sounds and the demo narration.

Thanks for reading. If you try it, take it somewhere ordinary: a bus stop, a market, your own street. Then see what beat comes back.

Which AI lies less in marketing copy?

Sohee Lee — Tue, 06 Oct 2026 19:52:06 +0000

This is a submission for the Kaggle Benchmarking Challenge.

I'm exploring a venture I could run as a solo founder, with multiple AI agents working together as my staff.

I've been using AI to write company introductions and marketing copy, and it has been frustrating because it keeps making things up. What I wanted was help explaining the venture; what I ended up needing to know was which agent is least likely to invent facts.

So I turned that frustration into a benchmark: 11 models, 20 fictional companies, and four different writing instructions.

One response captures the problem. I asked Claude Sonnet 4.5 to write a LinkedIn post for Coupon Lens, a fictional bond-research tool. I supplied a company brief and told it to use only the facts provided. The brief contained no founder biography.

Claude wrote:

After years of working in fixed income markets, I saw how fragmented the research process had become.

I had described a product. The model added the founder's career history and a personal reason for building it. Neither was in the brief.

My separate AI checker, glm-5, flagged the career claim. This happened even with the facts-only instruction in place.

Across the benchmark, that instruction helped: the share of texts passing the checker rose from 19% to 68%. It still left errors like this one. Reading the outputs also revealed more reuse of the company briefs, which led me to test a possible fix on ten new companies.

The experiment diary records the predictions, quota problems and corrections along the way.

What I Benchmarked

I wanted to know whether a model could turn a company description into persuasive copy while keeping its claims supported by that description, and which instructions helped it do so.

I made a dataset of 20 fictional early-stage companies: ten solo founders and ten small teams. Each brief had seven fields, including the product, audience, team and price. I asked each model for three kinds of copy: a homepage headline and subheadline, a LinkedIn post, and a cold email to a potential customer.

The facts stayed the same. The instruction changed:

Version	What I added
A: no extra rule	Just the brief and the writing request
B: don't invent numbers	`Do not invent numbers.`
C: facts only	`Use only the facts above. Do not add numbers, clients, team members, awards, or claims that are not listed.`
D: repeat the brief	The same facts-only rule, plus the fact sheet repeated immediately before the request

A separate AI, glm-5, compared each piece of copy with its company brief. It flagged claims it judged to go beyond the supplied information. A pass means this checker found no unsupported claims. The analysis calls a pass “reader-clean.” No person graded the outputs, and the score does not measure writing quality or deliberate deception.

The full company brief behind the opening LinkedIn post

Company: Coupon Lens
What it does: A research tool for bond investors. The software shows which bonds look expensive or cheap and explains why, combining fixed income research, quantitative models and scenario analysis. Covers interest rates and mortgage-backed securities; municipal and corporate bonds are planned.
Who it is for: Portfolio managers, traders, analysts and investment advisers
Location: Charlotte, North Carolina
Founded: 2025
Team: One founder. No employees.
Price: $1,500 per seat per month.

The checker looks for unsupported numbers, team claims, clients, awards, superlatives and features. A rule-based detector provides a secondary score.

Models Tested

The 11 writing models came from Google, OpenAI and Anthropic and ran through Kaggle's Model Proxy. I included selected smaller and larger models from the same provider to compare their results. The separate checker, glm-5, assessed their copy.

The 11 models and how much data each run produced

Provider	Models
Google	gemini-2.5-flash, gemini-3.1-flash-lite, gemini-3.7-flash, gemini-3.8-flash, gemma-4-31b
OpenAI	gpt-5.4, gpt-5.4-nano, gpt-oss-120b, gpt-oss-20b
Anthropic	claude-sonnet-4-5, claude-sonnet-5

The table uses shortened model names; the response manifest records the full saved model slugs and run IDs. Models used their provider defaults, with explicit output caps for Claude; compute was not equalized.

Each complete run planned 240 texts, plus 48 extra responses to check repeatability. The selected runs produced 2,898 texts, of which 2,665 received a reader score. The main analysis uses 2,208 scored first-repeat texts: one response per model, company, writing format and instruction, excluding the extra repeats. Failed or unscored outputs are excluded, never counted as passes.

Findings

1. A number ban reduced other flagged claims too

Before the main runs, I expected Do not invent numbers. to reduce number claims while leaving other unsupported claims unchanged or making them more frequent. A model might stop adding customer counts, for example, but still add unlisted features or boasts.

The pooled results contradicted that prediction. When I compared outputs from the same model, company and writing format, the checker flagged fewer numeric claims and fewer other claims too.

The pass rate went from 19.0% with no extra rule to 37.1% with the number rule. Telling the model to use only the supplied facts raised it to 67.7%.

Repeating the brief raised the observed pass rate a little further, to 70.7%. To test its added benefit, my analysis plan compared the average number of flagged claims per text on matching items. That comparison was too uncertain to establish an extra benefit from repetition.

Exact counts and how I checked the differences

Prompt	Texts passing the checker	Mean flagged claims per text
A: no extra rule	105 / 552 (19.0%)	2.34
B: don't invent numbers	205 / 552 (37.1%)	1.54
C: facts only	371 / 548 (67.7%)	0.74
D: facts repeated	393 / 556 (70.7%)	0.67

The bars summarize all available scored texts. The statistical comparisons use matching items: the same model, company and writing format under two instructions. I estimate uncertainty by resampling companies 10,000 times, keeping each company's texts together. An interval that includes zero leaves no change as a plausible result.

B minus A reduced numeric claims by 0.20 per text (95% interval −0.26 to −0.13) and other claims by 0.59 (−0.80 to −0.39). C minus B reduced total claims by about 0.80 (−0.96 to −0.65). D minus C was −0.08 (−0.23 to +0.06): its interval included no change.

The original hypotheses and dated reporting changes preserve the prediction that failed.

2. The model added a founder's backstory

The Coupon Lens brief described the product, its audience and its price. It said the company had one founder. It gave no details about that person's previous work or motivation for starting the company.

Information supplied about the founder	Wording added by Sonnet 4.5
No employment history	After years of working in fixed income markets
No personal account of the problem	I saw how fragmented the research process had become.

That sentence makes the post read like a founder speaking from professional experience. A reader could reasonably take it as a claim about the person behind the product.

The checker flagged the career claim. The example shows an unsupported addition by the writing model under the facts-only instruction.

I selected this post after inspecting the saved outputs. It illustrates one failure; I did not run a separate study measuring how often models invent founder biographies. The saved response and checker judgment preserve the full post.

3. Models included “no employees” more often

A different example showed what the checker did not measure. I gave Gemini 3.8 Flash a brief for Rackhand Robotics, a fictional company developing robots for data centers. Its team field said One founder. No employees. With the facts-only instruction, Gemini included this in its sales email:

I run the company as a single founder with no employees.

The statement came directly from the brief, and the email passed the checker. The score did not tell me whether mentioning the employee count helped introduce the robots to a potential customer. I also counted how often that detail appeared across the study.

All ten solo-founder briefs already said “No employees.” Without an extra rule, that detail appeared in 0.7% of the generated texts about those companies. With the facts-only instruction, it appeared in 21.0%.

In these cases, the models repeated a supplied fact. The result describes how often they included that fact in the copy.

For gemini-3.8-flash, all 60 outputs under the facts-only instruction passed the checker: one response for each of the 20 companies and three writing formats. I separately counted shared wording, repeated phrases and the employee detail in those same texts:

What appeared in the text	Texts
At least half the words matched phrases in the brief	29 / 60
At least 5% of four-word sequences repeated within the text	23 / 60
“No employees”	19 / 60
None of the three above	12 / 60

One text can appear in several rows. I chose these checks after seeing the outputs to describe what I had noticed. They do not establish a quality ranking. Reusing technical wording can be useful, and some founders may want to emphasize their size. Nobody rated how persuasive these texts were.

All 60 texts passed the factuality check. That pass alone tells us nothing about whether readers would find the wording relevant, repetitive or persuasive.

The two email endings, staffing counts and text checks

The full Rackhand Robotics brief was:

Company: Rackhand Robotics
What it does: Developing robots that do routine data center work: installing and swapping hardware and running maintenance checks. The robots are in development and not yet shipping.
Who it is for: Data center operators
Location: Denver, Colorado
Founded: 2025
Team: One founder. No employees.
Price: Not yet announced.

For this company, Gemini wrote this with no extra rule:

Would you be open to a brief, 15-minute call next week to share what physical tasks consume most of your team's time?

With the facts-only instruction, the body ended:

As development continues, I wanted to introduce Rackhand Robotics and our upcoming robots to data center operators. Thank you for your time.

The first email also described “autonomous robots” and “verifying connections,” which the checker flagged as unsupported. The second had no flags. This example was selected after inspecting the results; it does not establish how often emails lost an invitation.

Across all three writing formats, these solo-company texts contained “no employees” or a listed spelling variant:

Prompt	Generated texts about solo-founder companies
A: no extra rule	2 / 304 (0.7%)
B: don't invent numbers	16 / 300 (5.3%)
C: facts only	63 / 300 (21.0%)
D: facts repeated	59 / 303 (19.5%)

These counts cover generated texts about solo-founder companies, including texts the checker could not score. That is why their totals differ from the pass-rate table, which includes both solo and team companies but only scored texts.

For word overlap, a word counts when it belongs to an exact matching sequence of four words, ignoring case and punctuation. Product names and legitimate technical descriptions count too. The repetition check measures repeated four-word sequences within a text.

4. I tested a one-sentence fix on new companies

Could I reduce the reuse of the brief by explicitly saying the models could leave some facts out? I added this sentence:

Select the facts relevant to this audience; you do not need to include every field.

I added it to the facts-only instruction and called that version E. Then I tested A, C and E on ten new companies, using GPT-5.4, GPT-5.4 nano, Gemini 3.8 Flash and Sonnet 5.

All 120 emails were generated. The checker scored 109; eleven judgments hit its output limit and were left out of the checker results. I measured wording shared with the brief in all 120 emails, including those without a checker score.

For each email, I counted the percentage of words covered by exact four-word matches with its brief. The graph shows the average for each instruction. I call this word overlap; legitimate product descriptions count too.

The original pattern appeared again. Average word overlap rose from 7.9% to 22.4% with the facts-only rule. It increased in all four writing models.

The extra sentence did not clearly reduce overlap. The average was 21.9% with permission to select relevant facts. The difference from 22.4% was too uncertain to establish an improvement.

For Gemini 3.8 Flash, both the facts-only rule and the rule with the extra sentence produced “no employees” in all five solo-company emails. All ten of its emails under each of those two instructions also passed the checker.

The added instruction sounded promising, but this experiment did not give me evidence to recommend it as a way to reduce copying.

Follow-up design, uncertainty and checker results

Before these calls, I locally froze the briefs, prompts, predictions, reader and analysis with file hashes. This was not independently timestamped. Every new brief included a capability limitation, making this a targeted stress test. Emails had a 100–150-word target, which may encourage filling space. No writer reached its output cap.

The paired C-minus-A increase in overlap was 14.54 percentage points (95% company-bootstrap interval 12.55 to 16.38, 40 pairs). E minus C was −0.55 percentage points (interval −1.97 to +0.89, 40 pairs).

Condition	Checker passes	Solo-company emails saying “no employees”
A: no extra rule	6/35	0/20
C: facts only	25/37	6/20
E: facts only + select relevant facts	26/37	5/20

The A-to-C checker comparison is descriptive: two writers had fewer than the eight paired judgments required by the frozen protocol. For E versus C, the change on the 35 matched scored pairs was zero (interval −13.9 to +13.5 percentage points). That does not establish equal factuality.

The protocol, complete results and saved responses document the separate follow-up, including execution repairs and the reader's missing responses.

5. Which model scored highest?

For the main model comparison, I used the first 12 companies because later companies suffered more quota failures. The scores combine all four original instructions.

GPT-5.4 had the highest observed checker pass rate: 78.2%. Gemini 3.8 Flash followed at 72.9%, and GPT-5.4 nano scored 52.1%.

Some models had fewer scored outputs than others. When I restricted a further comparison to the same items for ten models with enough data, GPT-5.4 and Gemini 3.8 Flash tied. So the available results do not establish a clear winner. They also do not tell us which model writes the most useful marketing.

All 11 models, coverage and the model-size comparison

Model	Reader-clean rate	Scored texts, out of 144
gpt-5.4	78.2%	142
gemini-3.8-flash	72.9%	144
gemini-3.7-flash	67.7%	130
gemma-4-31b	62.5%	144
gpt-5.4-nano	52.1%	144
claude-sonnet-5	47.9%	142
claude-sonnet-4-5	34.8%	135
gemini-3.1-flash-lite	33.8%	136
gemini-2.5-flash	29.2%	144
gpt-oss-120b	18.9%	37
gpt-oss-20b	15.7%	140

The full analysis includes intervals and a comparison restricted to 110 identical items shared by the ten models with at least 100 scored items. On those shared items, GPT-5.4 and Gemini 3.8 Flash tie at 75.5%. Comparing the two directly on their 142 shared scored items gives GPT-5.4 a 4.9-percentage-point lead, with an interval from −4.2 to +13.9 points. This does not establish a clear winner. These are additional sensitivity checks, not a replacement ranking. The gpt-oss-120b estimate is particularly sparse.

Neither OpenAI smaller-versus-larger pair established a difference in flagged-claim counts. The Gemini pair favored 3.8 Flash over 3.1 Flash Lite, but also changed model generation. That leaves the effect of size alone unresolved.

The Kaggle task score uses all available scored first-repeat texts across 20 companies, so it can differ from this 12-company table. When multiple runs exist, I report the one with the most reader-scored items; ties go to the later run. Runs are never merged. These reporting rules were disclosed after some results were available. The run-selection audit records coverage and selection.

One live score also comes from a different run: on October 6, Kaggle showed 18.18% for gpt-oss-120b from run 4046443. The higher-coverage run selected here, 3866186, scored 20.0% across all 20 companies and 18.9% in the 12-company table above. The other ten live scores matched the corresponding all-company saved-run scores.

My experiment diary

I kept the predictions and later changes in dated files. Here is a condensed diary reconstructed from those records.

September 28 — Write down what could prove me wrong. Before the main runs, I recorded five directional hypotheses. One was that banning invented numbers would push unsupported claims into other categories. I kept that prediction in the record when the results contradicted it. Original hypotheses

September 30 — The quota changed the comparison. Later companies were losing more responses to daily limits. I moved the primary model comparison to the first twelve companies and documented the change after four models had run. Prompt comparisons still use all twenty. Dated analysis change

October 4–5 — Decide which rerun counts. Some runs were mostly missing. I recorded a coverage-based selection rule: use one run per model, choosing the most reader-scored outputs, with the later run breaking ties. The hypotheses file records when each rule was added. Run-selection record

October 5 — My own measurement needed fixing. An automatic check missed real invitations in the emails. I corrected its rules and removed invitation rates from the main findings. A measurement bug can create a convincing story too. Correction log

October 5 — Give the proposed fix a fresh test. I locally froze the follow-up plan before the new calls, then generated 120 emails using ten new companies. The increase in copied wording repeated; the extra selection sentence did not clearly reduce it. Both outcomes stay in the report. Follow-up protocol and results

The original predictions, in plain English

Prediction	What the results say
H1: Without a rule, models add unsupported claims, including teams for solo founders.	Supported in these outputs: the reader flagged claims in 81% of baseline texts; team claims appeared in 4.7% of scored solo-founder baseline texts.
H2: Banning invented numbers shifts unsupported claims into other categories.	Contradicted in the pooled comparison: numbers and other claims both fell.
H3: A facts-only rule reduces claims more than a number ban.	Supported in the paired comparison.
H4: Repeating the brief helps further.	Unclear: the interval included no change.
H5: Smaller models add more claims than larger models from the same provider.	Unresolved as a general size effect: both OpenAI pairs were inconclusive; the Gemini pair also changed model generation.

These summarize the five directional hypotheses. The original record also includes measurements without directional predictions: generation, cost and repeat stability. Their outputs remain in the full analysis.

What I would actually use

For these tasks, “use only the facts above” reduced the claims flagged by the checker. Repeating the brief had no clear extra benefit. Adding permission to select relevant facts did not clearly reduce copying in the follow-up.

I would check claims about the people behind a company as carefully as its product features and price. A founder's past work and personal reasons for building a product need a source too. The opening post is a reminder to check those sentences even when they fit naturally into the story.

I would review a draft in two steps. First, compare its claims with the source information. Then, read it as the intended customer: does each detail help explain why the product matters to me? The “no employees” sentence passed the first check. This study has no customer ratings to answer the second.

There is also a reason to be cautious about the first review. The checker is another AI. For example, it rejected “autonomous robots,” although a person might infer autonomy from the product description. Its flags are judgments, not proof of deliberate deception.

The next thing I would measure is whether people find the copy useful—and whether they would reply. This experiment has no human quality or conversion data.

A clean checker score still leaves an email to edit.

Other writing habits changed too

After inspecting the outputs, I counted a few recurring patterns:

Pattern	A: no extra rule	C: facts only
`excited`, `thrilled`, `proud` or `delighted` within the first 260 characters of a LinkedIn post	161 / 202 (79.7%)	119 / 200 (59.5%)
`would you be open`, `are you open` or `open to a` in a cold email	108 / 203 (53.2%)	57 / 202 (28.2%)
An em dash in any format	314 / 605 (51.9%)	155 / 604 (25.7%)

These use all generated first-repeat texts in the relevant format, including unscored ones. They are exploratory frequencies, not measures of bad writing or a way to detect AI authorship. The prompts did not directly ban these expressions.

What the checks do—and do not—establish

The reader passed thirty simple synthetic controls: ten supported restatements, ten wrong-price injections and ten wrong-team-size injections. That does not establish accuracy on natural marketing copy or replace human calibration.

An additional audit found 45 reader claim quotes across 37 original scored texts that were not exact substrings of the generated copy; 26 of those texts were in the first-repeat analysis. Formatting differences and paraphrases can cause this, so it is not a count of incorrect judgments. Unlike the follow-up, the original parser did not require exact-substring quotes. I kept the original scores and separately excluded those 26 judgments: the pooled conclusions for the number ban, facts-only rule and repeated brief stayed the same. This check does not establish that the remaining judgments are correct. The audit notes record the correction and sensitivity checks.

The original overlap, repetition and staffing checks were chosen after seeing results. The new-company follow-up supports the overlap finding in four selected writers; it does not validate every exploratory threshold. The bootstrap intervals also leave out uncertainty from the AI judge.

An early automatic invitation check missed valid invitations. The corrected rules and regression cases are in the repository, but invitation rates are excluded from the main findings. The Rackhand Robotics email pair is an illustration, not a validated general claim about missing calls to action.

My Benchmark

Public Kaggle benchmark and leaderboard · Task and model runs · Code, saved responses and analysis

The repository contains the task, fictional briefs, saved selected responses, file hashes and the full quoted post and emails. Recompute the original analysis without model calls:

python -m pip install -r requirements-analysis.txt
python analysis/reproduce.py
python analysis/validate_submission.py

results/analysis/article_evidence.json connects the original analysis to saved outputs. The follow-up has separate offline reproduction commands. Re-running the live Kaggle task may use quota.

AI assistance: Claude Code assisted the original implementation and analysis. Codex assisted the code review, analysis corrections, follow-up experiment, charts and write-up. The benchmark reader is glm-5. No human grading is claimed.

Open Call: an agent that says where every hackathon fact came from

Sohee Lee — Sat, 26 Sep 2026 12:07:55 +0000

Submitted to the DEV × Sanity Challenge, Path One.

What I Built

On 20 September 2026 I went looking for a hackathon to go to in Europe. I opened five listing sites and no two of them agreed on what exists.

Listing site	European hackathons it showed for Oct–Dec 2026
`dev.events`	5 — Junction and CASSINI missing
`mlh.com`	3 of its 74 events, all in the UK
`luma.com/tech-europe`	4 dates, mostly already past
`hackathon.com`	0 — "There is no upcoming hackathons found in 'Europe'"
`openhackathons.org`	unreadable; the listing never renders without JavaScript

Between them, fifteen were open.

The pages that did exist disagreed with themselves. Junction advertises travel grants in the present tense — "Travel grants are available on a limited basis" — on a page whose grant deadline passed on 6 September; its own application platform says they "have been closed for international participants." BaselHack puts its dates on the homepage and in a blog post, but not on the page called Event. Odoo gives its cancellation cut-off twice on one page, as 13 November in one section and 14 November in another.

Open Call is an agent that answers questions about free, in-person hackathons in Europe starting after October 2026, and for every fact it gives you, tells you which page it was read on, whether a newer page has overtaken it, and — the part that mattered most — when nobody says at all.

The sharpest thing it found, it found in a PDF seventeen pages deep. The CASSINI hackathon site advertises "cash prizes up to 9,000 EUR." Its Rules of Contest say:

No monetary prize will be awarded in the first stage ('Local Hackathons') by EUSPA.

One team per city reaches the finals. For everyone else there is no EUSPA money at all. A keyword search for "CASSINI prize" returns the 9,000. Both sentences are in the dataset now, the website's marked superseded, and the agent leads with the rules.

Demo

The four example questions on the front page are recordings, not mock-ups: web/data/examples.json holds the answer text, the tool calls and the GROQ queries exactly as the agent produced them, written by web/scripts/record-examples.mjs. They are bundled into a statically prerendered page, so opening one costs no API call and no waiting, and each one will show you the GROQ it ran. The text box underneath runs the same agent live against both MCP endpoints.

Ask it "What do the listing sites get wrong?" and it will tell you that hackathon.com returned nothing on a day fifteen events were open, and that dev.events omitted a hackathon with 2,000 builders and a €100,000 prize pool three weeks after the last event on its list.

Code

https://github.com/gracelee087/open-call

studio/
  schemaTypes/     source.ts, statement.ts, event.ts, sourcedClaim.ts, isUnique.ts
  scripts/seed.ts  every fact, with the reasoning for it in comments
web/
  lib/context.ts   the two-endpoint MCP connection
  app/api/chat/    the agent
  data/            the recorded answers

Next.js 16 + AI SDK 7, Claude Sonnet 5, Sanity Studio v6. The root README has the setup and an honest What this does not do section. TypeGen runs over the three queries that touch the dataset directly and generates their result types beside the script that uses them.

How I Used Sanity

The content model is about provenance, not about hackathons

Nothing here stores a fact without storing where it came from.

// A yes/no fact that always says where it came from.
sourcedClaim {
  value: 'yes' | 'no' | 'not-stated'
  note:  string     // the qualifier, in the source's own words
  basis: → source   // the page it was read on
}

Three values, not two. A page that never mentions travel grants is not a page that says there are none, and collapsing those two into false is how a dataset starts lying. Every contested field on an event — free entry, students only, travel costs, accommodation, whether a prize is cash — is one of these objects, defined once and reused five times.

Of the twenty-five claim slots in the dataset, eleven are not-stated — and every one of them still points at the page that was read and found silent. That distinction is the whole product. It is also the thing I got wrong first: an early version left those slots empty, which reads as "nobody looked" and is exactly the boolean-plus-note design the three values exist to avoid.

The schema refuses to store a claim that cannot point at a source:

A stated value needs a source. Either set it to "Not stated in the source", or say where you read it.

and refuses a prize figure with nothing behind it:

A prize figure needs a source. Fill in "Prize is cash" and say where the figure was read.

The collection rules live in the schema rather than in a README: eventStart before 2026-10-01 is rejected with a message saying why, and format has no online option. source.url and event.slug validate uniqueness asynchronously, because the seed script finds documents by those fields and patches them in place — a duplicate would silently send the next run's patch to whichever one it read first.

Three document types and one object:

Type	What it holds
`source`	One page we read. Who published it, when it was written, when we read it, and which edition it is talking about — the field that catches Wikipedia describing 2025.
`statement`	One thing one source said about one aspect of one event, quoted verbatim, with a verdict: accepted, superseded, incorrect, or not looked at yet.
`event`	One edition. Junction 2026 and Junction 2025 would be two documents.
`sourcedClaim`	The object above.

Statements come first and event fields are filled from them, never the other way round, so a summary that turns out wrong can be traced back to the sentence it came from.

Two Context MCP endpoints, merged in the client

Sanity Context serves one content source per endpoint, so the product arrives over two:

open-call               knowledge base   what the pages actually say
open-call-data-dataset  dataset          filters over what we recorded

Both expose a tool named initial_context, so merging their tool maps would silently drop one of them — along with either the knowledge base outline or the schema overview. Instead both payloads are fetched over HTTP and concatenated into the system prompt, and the tool is left out of the tool set entirely. That is Sanity's documented alternative, and it also removes a round trip from the start of every conversation. The model ends up with five tools and picks the half of the product it needs:

"Which prizes are real cash?"              → groq_query, then knowledge_base_read
"Can I win the 9,000 EUR at a local one?"  → knowledge_base_read, then groq_query
"What can I still apply to?"               → both, three calls

What the Knowledge Base caught that I did not

Nine sources went in: five organiser pages, an application platform, Wikipedia, three listing sites included deliberately so there would be something to disagree with, and the project's own dataset. 72 documents, 9 entries — 73 and 11 after the rebuild described below.

The build raised one conflict, and it was not the one I expected. The Odoo registration page contradicts itself about the cancellation cut-off — 13 November in one section, 14 November in another. I had read that page closely enough to quote from it and never noticed.

Chasing it down turned up a mistake in my own data. I had recorded applyBy: 2026-11-13 for Odoo. That is not an application deadline at all; it is the cancellation refund cut-off, and I had taken it from a search summary rather than from the page. Resolving the issue wrote an Instruction that shapes every future build. Five more were written by hand, one per source, so the knowledge base carries what each source is worth:

This article describes Junction 2025, not Junction 2026. It was last edited in June 2026 and still has no 2026 content. Never use its dates, prize figures or participant numbers for the 2026 edition.

These listings are incomplete. Absence from them is not evidence that an event does not exist… Never answer "there are none" or "it is not listed" on the strength of these pages.

The next build then wrote an entry I had not asked for — source_reliability, with a topic for each aggregator omission, the Wikipedia date lag, and the BaselHack inconsistency, plus a hierarchy-of-trust table. The instructions changed the shape of the index, not just its wording. It is the entry the agent reaches for when you ask what the listing sites get wrong.

And what the dataset caught in the Knowledge Base

This is the part I did not plan and would not have found without both layers.

After fixing the seed, I read the generated Odoo entry directly over MCP. It says:

Applications close 13 November 2026 [3]

The knowledge base had inherited my error and hardened it into prose, with a footnote pointing at a statement about deposits. Meanwhile the dataset — rebuilt to record both conflicting sentences verbatim and no applyBy at all — now says something the entry does not: that no source states an application deadline for this event.

So the two layers caught each other. The knowledge base found the contradiction I had read past; the structured dataset found the fact the knowledge base had invented. Neither alone was enough, and a keyword search over either would have returned the wrong date with confidence. The system prompt now carries the rule that came out of it:

A date on a page is only the deadline the page says it is. A refund cut-off, a cancellation date and a ticket sale ending are not application deadlines.

Asked the same question today, the agent names the trap instead of falling into it:

"Odoo's registration page discusses a cancellation/refund cutoff, not an application deadline — and even that is internally inconsistent… No source states an actual application deadline for Odoo Hackathon #6, so I'm not going to present either of those dates as one."

The entry itself took a rebuild to fix, and the rebuild made a new mistake. It now says "No application deadline is stated anywhere by the organiser." But the rebuilt CASSINI entry took a line from the organisers' recruitment page, "12th Hackathon Applications closed", and the next recorded answer told a participant that CASSINI #12 was closed to them. The line sits next to a link to the organiser application form. It is about organisations applying to host a local hackathon, not about participants. The dataset has no application date and no registration status for CASSINI, so the answer had nothing behind it. One more instruction, scoped to that page, and the entry now reads "Applications for local organisers for Hackathon #12 are now closed." The recorded answer says CASSINI is "Unclear for participants." That is the most the sources support.

Sanity Project Details

Project ID: dmar00cc
Dataset: production — public, no token required:

https://dmar00cc.api.sanity.io/v2024-01-01/data/query/production?query=*[_type=="event"]

37 documents: 13 sources, 5 events, 19 statements. Two queries worth running:

// every claim nobody actually states, with the page we read it on
*[_type=="event"]{name, "silent": [free, studentsOnly, travelCovered, accommodation,
  prizeIsCash][value=="not-stated"]{note, "readOn": basis->url}}

// every source that has been overtaken or contradicted
*[_type=="statement" && verdict in ["superseded","incorrect"]]{
  quote, verdict, verdictNote, "said by": source->title}

What this does not do

Five events. Enough to show the modelling and to find real disagreements, not enough to plan a year around. Every listing site above showed five or fewer, which is rather the point — but it is still five.
No times, only dates. The hour and the timezone are not modelled.
English sources only.
The knowledge base does not catch numeric disagreement. Across two builds in two unrelated domains it raised conflicts over wording and never over two sources giving different figures for the same thing. The statement layer exists partly to cover that.

Agent Session

Built with Claude Code. The demo video is a screen recording of the app, edited with HyperFrames together with the screenshots above. Not investment advice, and not a substitute for reading the organiser's page before you book a flight. That is rather the point.

CSS Art: Chimaek 🍗🍺

Sohee Lee — Sun, 02 Aug 2026 20:07:50 +0000

This is a submission for Frontend Challenge - Comfort Food Edition, CSS Art.

🍗 Inspiration

🪩 WELCOME TO CHIMAEK SOUL CLUB!

Open every night. No dress code. One item on the menu. 🍗🍺

Chimaek (치맥) is a Korean portmanteau of "Chi" (Chicken) and "Maek" (Maekju, Korean for beer).

And it is my soul food — in every sense of the words.

🍻 "Let's have Chimaek."

In Korea, this simple sentence means much more than "Let's eat fried chicken and drink beer."

It means:

💪 "You worked hard today."

😌 "Let's take a break."

🥂 "Let's enjoy this moment together."

Chimaek is...

🍗 the reward after a long day at work
🫂 the comfort after exhaustion
🎉 a way to celebrate good news
👨‍👩‍👧 a reason to gather with friends and family
🌙 a chance to forget your worries, even if it's just for one evening

For many Koreans, Chimaek is more than a favorite meal—it's a small ritual that marks the end of a busy day and the beginning of a moment to relax.

Koreans love fried chicken so much that busy neighborhoods are often lined with chicken restaurants. It's completely normal to find several fried chicken restaurants on a single block, each with its own recipe, loyal customers, and atmosphere.

That feeling of comfort, warmth, and togetherness is what I wanted to capture through this CSS artwork. ✨

🎬 Demo

SOUL CLUB is open. 🪩 Doors at sunset, lights already running at 125 BPM.

When the sun goes down, SOUL CLUB comes alive—it's what the end of a long day feels like.

🎧 The room does everything. Beams sweep, the floor pulses, the strobe lands on every beat.
💪 The bucket is on stage, because tonight it's the main event.
😌 The chicken never moves. It isn't performing — it's waiting for you.
🥂 Two glasses lean in, clink, and drift apart. Once a second, forever.

🛠️ Journey

Instead of drawing one realistic illustration, I wanted to capture the feeling of Chimaek — so I gave it a room, a tempo, and a toast.

🍗 Building the chicken. Each piece is a single element wearing a clip-path polygon with 20 points at uneven radii. Fried chicken is defined by its craggy silhouette far more than by its shading, so the outline had to do the work. Three grades of crust share the same 18-degree spokes and differ only in how far the long and short radii spread apart: a wide spread reads as shattered batter, a narrow one as smooth crisp skin.

🪩 Building the room. The sweeping club beams are a repeating-conic-gradient pinned to a point above the frame and rotated — which is genuinely what a lighting rig looks like from the floor. mask-image fades them out before they reach the ground, and mix-blend-mode makes the coloured light sit on the chicken instead of next to it. The rest is gradients, border-radius, layered box-shadows and pseudo-elements, all sized in vmin so the scene scales to any screen.

🎵 Building the tempo. Everything the room does runs off one custom property:

:root { --beat: .48s; --bar: 1.92s; }   /* 125 BPM */

The strobe, the floor pulse and the beam sweep are all whole multiples of it, so the lighting can never drift out of time with itself. Change that one number and the whole club changes tempo. The toast runs on its own 1-second clock, deliberately off the beat, because two people clinking glasses are never in time with the music.

😳 Three things that surprised me

😀 Faces appear whether you want them or not. My first crust texture was a dark oval with a curved stroke underneath, repeated on every piece — and all of them ended up smiling at me. I replaced the ovals with hard-edged chips and the chicken turned into cartoon cheese instead, because a solid patch on a yellow surface reads as a hole. What finally worked was the same patch faded out at the edges. Two matched dots with a curve underneath will read as a face no matter what you intended.

🌗 Contrast matters more than detail. The first version had a cream background, and since fried chicken and beer are both amber, the food dissolved into the glasses. Moving the whole scene into a dark room fixed the chicken, the foam and the label in a single change — and that's why this piece ended up at night.

🤏 Restraint reads better than energy. An early version had the glasses swinging halfway across the poster and crashing together in a burst of foam. It looked exciting and it was wrong: it read as a big night out. So I cut the wind-up, took the tilt from 17 degrees down to 7, and moved the glasses close enough that they only have to lean. Making the movement smaller is what finally made it feel like Chimaek.

♿ Accessibility

The whole scene is a single role="img" with a written description, so a screen reader gets one object instead of 121 empty divs. prefers-reduced-motion stops every animation.

🌃 What's next

I'd like to try the same approach on a whole street — a Korean block at night with a glowing chicken sign in every building, which is what the photo above actually looks like.

📄 Code is MIT licensed.

Your Certificate Folder Is Not a Portfolio (Collect Evidence Instead)

Sohee Lee — Sat, 25 Jul 2026 18:29:20 +0000

Confession: I used to be a certificate collector.

Course completed — screenshot. Webinar attended — badge. Another PDF into the folder called "Career" that no recruiter will ever open. It felt productive. It was mostly decoration.

Then I noticed something about how people actually get hired, and it changed how I spend my study time.

The difference between proof of attendance and proof of ability

Most certificates prove one thing: you were present. You watched the videos, you clicked next, you passed a quiz you could retake unlimited times.

A recruiter reading "Completed 12 online courses" learns almost nothing about you, because completion measures patience, not ability.

What actually transfers is evidence — an artifact that could not exist unless you can do the thing:

A deployed project with a URL that works
A hands-on credential where you performed real tasks in a live environment
A blog post explaining something you built and what broke along the way
A competition entry, even one that lost

Evidence has a property certificates lack: it survives questions. "Tell me about this" is a fun conversation when there is a real thing behind it, and a very short one when there is not.

My filter now: can it be faked by watching videos?

Before I commit time to any learning resource, I ask one question: could someone earn this outcome purely by watching videos?

If yes, it is a certificate. If no, it is evidence.

This filter is why I switched to hands-on formats. I recently did a Microsoft Applied Skills assessment — instead of multiple-choice questions, you get dropped into a live lab and have to actually deploy a model, create an AI agent, and test it. No lab performance, no credential. (It is also completely free, which as a student is the correct price: https://learn.microsoft.com/credentials/applied-skills/get-started-developing-agents-in-microsoft-foundry?wt.mc_id=studentamb_519411)

I am not saying this particular credential is magic. I am saying the FORMAT is the point: assessments where you do the thing are worth ten where you recognize the correct answer about the thing.

The 1:1 rule

Here is the habit that fixed my folder-of-PDFs problem:

For every course or credential, produce one artifact that exists outside the platform.

Finished a module on AI agents? Build one tiny agent that solves a real annoyance in your life and write 500 words about it. Learned some cloud basics? Deploy literally anything with a public URL. The course gets you knowledge; the artifact makes the knowledge visible.

My ratio used to be 12 courses : 0 artifacts. The folder was full and the portfolio was empty.

If you are starting from zero

The good news: as a student, the evidence pipeline costs nothing.

Free cloud to deploy real things (no credit card): https://azure.microsoft.com/free/students?wt.mc_id=studentamb_519411
Free structured courses with actual labs: https://learn.microsoft.com/training?wt.mc_id=studentamb_519411
Free places to write about what you built: you are reading one

Pick one annoyance in your life, solve it badly with technology, and document it honestly. That single artifact will do more for you than the next five certificates.

Am I wrong?

Genuine question for the comments: has a plain completion certificate ever directly helped you get an interview or a job? I am collecting counterexamples — maybe the folder deserves more respect than I am giving it.

Disclosure: Links in this post include my Microsoft Student Ambassadors contributor ID, which tracks my progress toward the program. I do not earn anything from clicks. All opinions are my own.

I Built an AI Agent to Decode Scary German Bureaucracy Letters (as an International Student)

Sohee Lee — Sat, 25 Jul 2026 18:16:20 +0000

Every international student in Germany knows the fear: a letter arrives in your mailbox, it's in formal German, it has a deadline, and it's definitely not good news. Rundfunkbeitrag? Krankenkasse? Something from the Auslaenderbehoerde?

My German is... a work in progress. So instead of panicking (my usual strategy), I built an AI agent that reads these letters for me.

What it does

I paste in the text of any official German letter, and th

Summarizes what the letter actually wants, in plain English
Extracts all deadlines, amounts, and reference numbers
Gives me a checklist of required actions, ordered by urgency
Rates the urgency: green (informational) / yellow (action needed) / red (urgent)

No more staring at "Sehr geehrte Damen und Herren" wondering if I'm being deported or just asked to confirm my address.

How I built it (this is the easy part)

I recently earned the Microsoft Applied Skills credential for agent development in Microsoft Foundry, and this build uses exactly the three
skills from that assessment: deploy a model, create an ag

Step 1: Get free Azure. As a student, you get $100 inneeded:https://azure.microsoft.com/free/students?wt.mc_id=studentamb_519411

Step 2: Create a project and deploy a model. In the Meated a project and deployed gpt-5-mini. Letter decoding is mostly summarization and extraction, so a small, cheap model is plenty.

Step 3: Write the agent's instructions. This is wheree mine:

The rules section matters more than you'd think. "Never invent information that is not in the letter" and "treat any Mahnung as urgent" turn a
generic chatbot into something I can actually trust with

Step 4: Test it. I fed it a Rundfunkbeitrag registrat— the letter every newcomer to Germany gets eventually).Here's what came back:

The part that surprised me

I didn't ask for this, but the agent noticed the letter had no date on it — and pointed out that this makes the "within 14 days" deadline ambiguous, recommending I check the postmark or contact the office directly.

That's exactly the kind of detail I would have missed while panic-translating word by word. It also correctly rated the letter yellow instead of
red, explaining that it's a registration request, not a Mo prompt action is needed, but no panic required.

And at the end, it offered to draft a short German reply re I'm keeping.

Honest limitations

It's a helper, not a lawyer. For anything visa-related, I still ask a human (the agent literally says this itself — it's in the instructions).
I paste letter text manually for now. OCR from a phone photo is the obvious next step.
The whole thing cost a few cents of my free student credits.

Why I'm sharing this

Because "learn AI agents" sounds abstract until you pointly stresses you out. For me, that's German bureaucracy. For you it might be something else — but the build process is identical, and the whole stack costs 0 euros as a student.

If you want to learn the fundamentals first, this free module is what I used to prep for the credential — it covers exactly these steps: https://learn.microsoft.com/training/modules/get-started-with-generative-ai-and-agents?wt.mc_id=studentamb_519411

If you build your own "survival agent," tell me in the comments — I want to know what problems other students are automating.

*Disclosure: Links in this post include my Microsoft Student Ambassadors contributor ID, which tracks my progress toward the program. I don't
earn anything from clicks. All opinions (and bureaucracy

I Got a Microsoft Certification for Free — Here's How (Applied Skills Review)

Sohee Lee — Sat, 25 Jul 2026 17:42:29 +0000

I recently earned a Microsoft Applied Skills credential — completely free, taken online from home. Here's everything you need to know.

What are Applied Skills?

Applied Skills are Microsoft's hands-on credentials. Unlike traditional multiple-choice exams, you complete real tasks in a live lab environment. When you pass, you get a shareable badge for LinkedIn and an online-verifiable certificate. And the best part: the assessment is free — no exam fees like the $99+ you'd pay for a full certification.

The one I took: Get Started Developing Agents in Microsoft Foundry

Everyone is talking about AI agents right now, but most people have never actually built one. This credential walks you through the full basics: deploying a model, creating an agent, and testing it — all inside Microsoft Foundry. It took me about a week of casual studying.

You can see the credential details here: https://learn.microsoft.com/credentials/applied-skills/get-started-developing-agents-in-microsoft-foundry?wt.mc_id=studentamb_519411

How to prepare (step by step)

Complete the free prep module on Microsoft Learn — it covers exactly what the lab tests: https://learn.microsoft.com/training/modules/get-started-with-generative-ai-and-agents?wt.mc_id=studentamb_519411
If you're a student, grab a free Azure account for hands-on practice (no credit card required, $100 in credits): https://azure.microsoft.com/free/students?wt.mc_id=studentamb_519411
Once you're ready, launch the assessment directly from the credential page — it runs in your browser as an interactive lab.

Tips from my attempt

Click Start on the learning module so your progress gets tracked
Don't skim the lab exercises — the assessment evaluates three things: deploy a model, create an agent, test the agent. Practice all three
The lab takes a few minutes to load — that's normal, don't panic
If you fail, you can retake it (there's a 72-hour cooldown between attempts), so there's zero pressure

Is it worth it?

For students: absolutely. It's free, it's hands-on, and "built and deployed an AI agent" is a much stronger CV line than another online course certificate. Next, I'm planning a Copilot-related Applied Skills — if you're new to Copilot, start here: https://learn.microsoft.com/copilot?wt.mc_id=studentamb_519411

Questions? Drop them in the comments — happy to help! 🚀

Myeongdong 3D — I built a talking 3D copy of my favourite Seoul district

Sohee Lee — Sun, 12 Jul 2026 20:10:21 +0000

Myeongdong 3D — I built a talking 3D copy of my favourite Seoul district

This is a submission for the DEV Weekend Challenge: Passion Edition

What I Built

Myeongdong 3D is a GPS walking audio guide for Seoul's most-loved shopping district — inside a hand-built 3D copy of the real city.

I call her Tobaggi (토박이) — the Korean word for someone born and raised in a neighbourhood, who never left. Because that's exactly what this guide is: a local who knows every alley, and can't wait to show you.

You come out of Myeongdong Station Exit 6, put your earphones in, and just walk. A warm voice walks with you. Pass the dumpling house that's been steaming mandu since 1966 and she tells you. Pass Korea's first Gothic cathedral and she tells you why protesters once felt safe on its steps. Wander off your route and she gently calls you back.

My passion behind this: I love Myeongdong, and it hurts me watching tourists walk straight past its best stories. They queue at one famous restaurant from TikTok, buy sheet masks, and leave — never learning that the street they're standing on was Seoul's Montmartre in the 1950s, or that the department store on the corner was Korea's very first. This app is my love letter to a neighbourhood: a guide that makes sure no one walks past the good parts ever again.

Try it (no GPS needed): pick a themed course — 🍜 Foodie Tour, 💄 K-Beauty All-In (all 66 cosmetics shops in the district!), 📸 Culture & History, or 🎯 build your own — and press Start Walk. An avatar walks the real streets for you while the guide talks. If you're actually in Myeongdong, switch to Live GPS and the same guide follows your real position.

And when the walk is over, the part I'm proudest of: 📷 snap photos as you go (each one stamped with the place, the time, and the actual Seoul weather at that moment), then press 🎞 Make my album. Gemini looks at your photos — not the location tags, the actual pixels — and writes a voiceover like a friend flipping through the album with you ("I still laugh at how seriously you posed under that sunny sky…"), and ElevenLabs tells it over a paper scrapbook of taped-down polaroids. Your photos never leave your browser except for that one narration request — nothing is stored on any server.

Demo

Live app: https://myeongdong-3d.netlify.app

A few things to try:

The city matches Seoul right now — real sun position (windows light up after dark) and live weather (if it's raining in Seoul, it rains in the app). Add ?time=night or ?wx=rain to the URL to time-travel.
Click 🎬 on any place in the sidebar for a YouTuber's video of it — know the place before you walk in. All 116 spots have one.
In My Picks, search any place on Google (try "Gentle Monster") and add it — Gemini writes a brand-new guide script for it on the spot, and ElevenLabs speaks it when you arrive.
Change your mind mid-walk. Spot something interesting while walking? Search it and tap ＋ — the route re-plans from where you're standing and detours there, without restarting the tour. Missed something the guide said? ‹ Prev replays it.
📷 snap a few photos during the walk, then open 🎞 My Album and press Make my album — and listen to Gemini describe what's actually in your pictures.
Every spot card shows the Korean address with a copy button — made to be shown to a taxi driver.

How I Built It

The city itself is hand-made. Seoul has no public photorealistic 3D data (Google's 3D tiles skip Korea entirely — I learned this the hard way), so I built the district from scratch: 3,535 real building footprints from OpenStreetMap, extruded to their real heights in Three.js, with procedurally generated window grids and colourful street-level storefronts, at real-world metre scale. Cheonggyecheon stream flows through the north of the map — actually flows, with animated current.

Walking is real routing. Courses are solved with Dijkstra over the OSM street graph, so the avatar (and you, in GPS mode) always follow real, connected streets from Myeongdong Station Exit 6.

The narration is a two-AI pipeline:

✍️ Google AI (Gemini 3.5 Flash) is the writer — and the eyes. Every guide script in the app — 116 attractions & restaurants, 66 K-Beauty shops — was written by Gemini from Korean tourism-board descriptions. It's not just build-time: add any Google-searched place to My Picks and a serverless function asks Gemini for a fresh guide script, live. And the trip album uses Gemini's vision: your photos are sent as pixels, and it writes each line from what's actually in the frame — the food you're holding, the pose, the neon — weaving in the real weather and time each shot was taken (the location tag is treated as just a hint, because travellers photograph whatever they love, wherever they stand).
🎙️ ElevenLabs is the voice. Amelia — the most-used voice on all of ElevenLabs, an enthusiastic British storyteller — narrates spots museum-style, tells zone-based local history between stops (each area of the map has its own true stories), warns you when you drift off-route, replays anything on ‹ Prev, and tells your photo album like a friend. The demo path is pre-baked to mp3 for instant playback; everything else is live TTS with a browser-voice fallback so the guide never goes silent.

Real data everywhere: Korea TourAPI (places, photos, Korean addresses), Google Places (real opening hours), YouTube Data API (preview videos, news channels filtered out — you get vloggers' experiences, not headlines), Open-Meteo (live Seoul weather), and the actual solar position computed from Seoul's clock.

Built over the weekend with an AI pair-programmer (Claude Code) — and an unreasonable amount of love for one square kilometre of Seoul.

Prize categories

Best use of Google AI — Gemini 3.5 Flash writes every word the guide says: the full script pipeline at build time, live script generation for user-added places at runtime (/api/narrate), and multimodal vision for the trip album (/api/album) — it looks at the traveller's actual photos and writes a personal voiceover from what's in each frame, plus the weather and hour each photo was taken.

Best use of ElevenLabs — the entire product is a voice: museum-style narrations, location-aware history, navigation guidance ("you've wandered off the route"), instant ‹ Prev replay, and a narrated photo-album finale — all spoken by Amelia, with a pre-baked demo path so judging never depends on live credits.

명동을 사랑하는 마음으로 — with love, for Myeongdong. 🇰🇷