DEV Community: Sohee Lee

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. 🇰🇷