DEV Community: Mike “Demo” Demopoulos

Grass Journal: a private voice journal that wants you to put your phone down

Mike “Demo” Demopoulos — Wed, 07 Oct 2026 02:18:13 +0000

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

What I Built

I do my best thinking on walks. Not at a desk. Halfway around the block, when a thought finally finishes itself, and I need somewhere to put it before it's gone.

Grass Journal is the somewhere. It's a voice and text journal that runs entirely on your device. No account, no backend, no analytics. Your entries live in your browser's local database and nowhere else. It transcribes voice notes with Whisper tiny.en and writes optional reflections with Qwen2.5-0.5B or Gemma 2 2B IT, your pick. Every model runs on-device, in the browser. The app makes zero network requests.

Your thoughts stay with you. That's the whole product.

Touch grass: the phone case says it before I do.

Getting people off the screen is the design brief, not a side effect. Three ways to capture a moment, each built to take seconds:

Speak. Hit record, talk, done. The app saves your audio before it does anything else, then transcribes on-device. Transcription fails? You still have the recording. Nothing uploads anywhere because there's nowhere to upload it to. This is the walking mode. Speak while you move.

Tap. The /watch/ page is a feeling wheel for your wrist. Eight feelings, one tap, saved in about ten seconds. I built it for the Apple Watch web viewer, which gives web pages no microphone and hijacks long-press to open a new tab. So: tap a feeling, put your wrist down, keep walking.

Write. A plain text editor with autosave. No toolbar fighting for your attention.

Type, and it's saved on your device before you lift your thumbs.

It's for anyone who thinks better outside and wants a journal that respects that instead of competing with it.

Demo

Try it live:

Grass Journal

A private, offline-first voice and text journal. Your thoughts stay with you.

grass-journal.view.fast

The 10-second version:

grass-journal.view.fast

Full demo (54 seconds):

Tap the hub, tap a feeling, saved. Phone resolution, real interaction.

The wheel on a real Apple Watch, out in the world. Ten seconds, one tap, wrist back down.

On the full app, record a voice note and watch it transcribe with the network idle. Then open the privacy screen and run the check yourself:

The app's own audit, runnable by anyone: "Passed — zero network requests during the test."

The AI setup screen is where you pick your reflection model:

I took it to the USMNT game. Getting through security was frustrating, so I opened the wheel on my watch and tapped how I felt — no data, didn't matter. Being able to capture it in the moment instead of reconstructing it later is the whole point. And having a way to continue my Fable journaling habit is good too.

What's verified and what isn't. The challenge grades technical execution, so here's the honest version:

Voice capture, transactional save, SHA-256 integrity checks: covered end-to-end in automated tests (12/12 Playwright, 50/50 Vitest on this build).
Whisper tiny.en transcription and Qwen2.5-0.5B reflection: verified on desktop Chrome with WebGPU.
Offline: it's a PWA with a full offline cache. Model weights download once, then everything runs with no connection.
Apple Watch: the page loads and the wheel works on a real watch. watchOS gives web pages no microphone, so there's no voice capture there. That's Apple's restriction, not a bug. It's why the wheel exists.
Reflection quality: these are small models. They write short, simple reflections. I claim nothing more. No WebGPU? You get a deterministic keyword fallback instead.

Code

Mike-Demo / grass-journal

A private, offline-first voice and text journal PWA. Your thoughts stay with you.

🌱 Grass Journal

A personal project. Built by Mike Demopoulos for personal use and shared publicly as-is. No warranties, no support queue — just the app as it runs.

A private, offline-first voice and text journal — as a Progressive Web App.

Core promise: “Your thoughts stay with you.”

No account. No backend. No cloud. No analytics. No ads. No remote transcription or hosted AI. Entries, recordings, transcripts, and reflections live in IndexedDB on your device. On-device AI (Whisper transcription, Qwen reflection) is optional manually triggered, and never blocks saving.

Product principles (in priority order)

Never lose the original entry.
Never send journal content to an external service.
The journal works without AI.
AI never blocks saving.
Audio is saved before transcription begins.
Original content is authoritative; AI output is optional metadata.
No user account. 8. No cloud service.
Brief interactions — then back to real life.
Privacy claims are…

View on GitHub

Personal project, MIT. The repo has everything: React + TypeScript + Vite PWA, Dexie.js over IndexedDB, MediaRecorder capture, encrypted backups (AES-GCM-256, PBKDF2 with 600k iterations), and the on-device AI workers.

How I Built It

Open weights all the way down:

Whisper tiny.en (MIT) handles every transcription, on-device, through Transformers.js in a Web Worker.
Reflection runs on-device through WebLLM, also in a worker, and you choose the model: Qwen2.5-0.5B-Instruct (Apache 2.0, default, ~450 MB) or Gemma 2 2B IT (Gemma Terms of Use, ~1.5 GB, usually richer). The worker loads whichever you picked. Every saved reflection records the model ID and the versioned system prompt, so you can always trace what wrote it.
The prompt asks for JSON and the client validates the reply, retrying once with a repair prompt when parsing fails. I skipped grammar-constrained decoding on purpose: WebLLM's xgrammar WASM won't initialize on iOS WebKit. Plain code validation instead.
No WebGPU, no problem: reflection falls back to deterministic on-device keyword tags. AI never blocks saving. The entry saves first, always.

Full credits for every library, model, and tool — with licenses — are on the open-source credits page.

And the disclosure the challenge asks for: I built this October 5–6, inside the challenge window, with an AI coding agent (Muse). I set the architecture, the privacy constraints, every product call. The agent wrote code; I verified it against the test suites and real devices.

Yes, there's irony in using a cloud-scale model to build the thing that frees you from cloud-scale models. I'll take it.

Why Does Open Innovation Matter?

I don't want my journal entries on someone else's server. That's the whole reason this app exists in this form.

Every journaling app with cloud AI asks you to make the same trade: hand over your most private thoughts so a model you can't see can process them on hardware you don't control. The privacy promise is always a paragraph in the terms of service. I've read enough of those paragraphs to know what they're worth.

Open weights end the trade. Whisper, Qwen, and Gemma run on my device, in my browser. Nothing leaves. And you don't have to take my word for it, which is the part I like best: the privacy screen runs a check that intercepts every network request and shows you the result. Try getting that from a closed API. The most sensitive part of their app is a black box they rent by the token. Mine is code you can read and models you can download yourself.

Three more places the open approach wins, concretely:

It works where journals get written. I take this outside. A closed-API journal dies without signal, which is exactly when you want it. That's not a limitation; it's a design contradiction. Local inference resolves it.

It costs nothing per entry. Metered APIs make you ration the feature. A local model makes it free to use and free to ignore. I reflect on walks, not on budgets.

You can change its mind. Two models on one screen, switch whenever. The model is a file. Not a vendor relationship, not a pricing page.

The closed alternative isn't a worse journal. It's a journal that ships your inner life to infrastructure you don't control. I built the other one.

Prize Categories

Overall prize
Best Use of Gemma — Gemma 2 2B IT runs locally via WebLLM as a first-class reflection model. Install it from the AI setup screen, and the entry screen uses it.

Hat tip

This build was inspired by apps that take inner life seriously:

View this post on Instagram

Fable - Live a Better Story Through AI Journaling

AI-powered journaling that reveals the epic story your life is already telling

getfableapp.com

View this post on Instagram

QueerCade: Both Sanity Challenge Paths, One Arcade

Mike “Demo” Demopoulos — Sun, 04 Oct 2026 22:59:47 +0000

I built QueerCade — a curated arcade of LGBTQ+ video games — through both paths of the Sanity challenge. One dataset powers all of it.

Path One: Ship an Agent That Queries Real Content

Sanity Challenge Path One Submission

Mike “Demo” Demopoulos

Sep 21

QueerCade (Part 1): Ship an Agent That Queries Real Content

#devchallenge #sanitychallenge #sanity #ai

4 min read

The QueerCade Discovery Guide is an AI agent that recommends games, characters, developers, and studios — answering only from the Sanity dataset (3,500+ documents). It never invents a game; if something isn't in the data, it says so.

Path Two: Vibe-Code Something Strange

Sanity Challenge Path Two Submission

Mike “Demo” Demopoulos

Sep 29

QueerCade (Part 2): Vibe-Code Something Strange — an Arcade of Queer Games on Sanity

#devchallenge #sanitychallenge #sanity #ai

4 min read

The arcade itself: a retro 8-bit pixel-art storefront with the Queer Character Constellation (870+ LGBTQ+ characters plotted as stars across decades) and the Emoji Game Oracle. Every screen, filter, and graph reads from Sanity via GROQ — no other content database.

One content lake, three experiences: a storefront, an MCP-queryable agent, and a celestial graph. Built on Sanity.

Inspired by

Gayming Magazine (@gaymingmag) / X

The home of queer geek culture 🏳️‍⚧️🏳️‍🌈🎮🕹️ Using this platform to celebrate LGBTQ+ excellence in an act of rebellion against its owner. 💪

x.com

AI Disclosure

AI assistance for this project:

Superhuman GO for MCP agent testing
Microsoft Copilot for idea planning
GitHub Copilot and Lovable for code
Grammarly for editing review, with human edits
Balsamiq AI for wireframe layouts

Eat Well AI: an in-browser AI that finds restaurants for every diet

Mike “Demo” Demopoulos — Sun, 04 Oct 2026 21:20:09 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

I'm excited to take part in the Hacktoberfest Weekend Challenge: Build for a Friend, where makers worldwide solve real problems for people they care about.

What I Built

Eat Well AI empowers people with dietary needs to discover restaurants that actually welcome them. Forget complicated filters—just express what you want in your own words, and Eat Well AI does the rest. Find food that fits your life, not just your diet.

"vegan pizza in Chicago"
"kosher in Miami"
"gluten free tacos"

An open-source algorithm that runs in your browser. It converts your sentence into search filters. Isn't that pretty neat? There's no need for servers or API keys since your sentences remain on your device.

I built Eat Well AI for my friend Miriam, who keeps kosher and often struggles to find places to eat when we travel. As a vegan myself, our outings always meant an exhausting search for spots that welcome both our needs. Eat Well AI finally answers that question: Where can we both eat, easily and confidently?

The search now spans over 1,000 restaurants in 37 cities, each carefully labeled for vegan, vegetarian, gluten-free, kosher, and halal options. Results appear as rich, interactive cards—complete with directions—so users can go from query to table in moments.

Demo

Try it live:

Eat Well — dietary restaurant finder for the Tufty 2350 badge

Playable web demo of Eat Well: 557 vegan, vegetarian, gluten-free, kosher and halal restaurant picks across 14 US cities, searchable in plain English with Qwen3 running in your browser, with a MapQuest QR code for every spot.

eat-well-ai.view.fast

If you use Chrome or Edge on a device that supports WebGPU, the model will download once (approximately 340MB) and afterwards all the features will function on your device.

Watch the 55-second demo:

URL:

Type it in clear English:

Results with map QR codes:

The admin side, adding a listing:

Code

https://github.com/Mike-Demo/eat-well-ai — MIT licensed.

How I Built It

The stack consists of plain HTML, CSS, and JavaScript served as static files; the restaurant database is in a single data.js file, and a search script filters it.

Alibaba's open-weight Qwen3-0.6B model can be run in the browser via WebLLM and WebGPU; I have hosted the model weights on the same static host, the page never makes a call to HuggingFace or any other API at runtime.

When you enter a query, the system interprets it and converts it into a formatted filter consisting of information about diets, the city, and cuisine keywords. The model's output is constrained using a JSON grammar (through WebLLM's response_format), which ensures that malformed output cannot occur. A model with a size of 0.6B will not comply with the instruction to "reply in JSON" by itself; the grammar overcomes this by design. If the model engine fails, a simple keyword parser then takes over so that the search can still function.

The JavaScript filters the restaurants and then displays the cards.

Eat Well AI evolved from Eat Well, the version I created for the Pimoroni Tufty 2350 microcontroller badge, which had 557 restaurants, physical buttons, and no possibility of using AI; the app for that badge operates in a panel below the search box and uses the same code and pixel art.

Why Open Innovation Matters

The hosted AI API was obviously the quickest way out and I decided not to use it for three reasons.

Privacy is the most important consideration. Individual dietary requirements are a matter for the person concerned. When you enter a query such as "kosher near me" you are giving information about both your religion and your location. The model operates on your device and so that sentence never gets sent to a server.

The cost is a close second. With hosted models you are charged on a per-query basis. This one has no cost per query. The entire cost is due to static file hosting.

Control is third; with open weights I am able to self-host the model, replace it at a later stage, and adjust the prompt. Since the small model was ignoring my JSON instructions, I restricted its output using a grammar rather than submitting a support request. Before shipping, I checked the prompt by running the same weights on my own machine.

Turning the weights open turned what had been a weekend project into one that I could give to a friend without having to hand her any of my data.

Inspired by

HappyCow (@HappyCow) / X

Discover vegan food near you 🌏 #1 vegan app 🐮 180+ countries, 4M+ #HappyCowmunity 🌱 Grow the moo-vement together 💜 Download the app!

x.com

AI Disclosure

AI tools used on this project and write-up, and how:

Grammarly — edited this post: grammar and spelling fixes, tone passes with its humanizer (Naturalist profile), AI-phrase detection and rewrites, and "make it more impactful" suggestions. Every suggestion was reviewed and approved by the author before applying.
GPTZero — scored drafts for AI-likeness during editing, used as a rough signal rather than a verdict.
Pexo — generated the 55-second demo video from the project brief (4K, no voiceover).
Adobe Firefly — generated the pixel art used in the app and badge UI.
Qwen3-0.6B (Alibaba) — the open-weight model that powers the app's in-browser natural-language search, running locally via WebLLM and WebGPU.

Everything else — the code, the dataset, the MapQuest integration, and the final words — is the author's own work.

Can LLMs audit multi-agent prompts? I made them grade my robot football team.

Mike “Demo” Demopoulos — Thu, 01 Oct 2026 16:16:19 +0000

This is a submission for the Kaggle Benchmarking Challenge

What task(s) did you run?

In the first Agentic Football Cup — a simulated football league in which each 'player' on the teams is an LLM agent controlled using a prompt file — I conduct a manual audit of those prompt files before each match window, looking for bugs such as collisions between forwards in zones, loopholes in the handoff procedures between defenders, and scope conflicts in the anti-spam rules. This process is time-consuming.

There was a desire to know: could a large language model carry out the audit instead? And more importantly – could I place trust in it?

So I created a benchmark that acts as a junior auditor and evaluates the model against the ground truth I already have. The task provides the model with two items:

A retired team-prompt JSON (one of three Bugle Crowns builds)
The same stress-test audit prompt a human would follow

The system must provide the structured findings—including the defect ID, a GREEN/YELLOW/RED flag, and a direct quotation of the evidence—and also give one final decision, either SHIP AS-IS, FIX-THEN-SHIP, or DO NOT SHIP. Provide only the findings, with no rewrites.

The three builds are the clever part:

v2.5A.1 — a faulty version containing three known defects (a collision in the defensive-corner zone, a loophole in the intercept lane-handoff, and a conflict between the anti-spam scope). The audit has to identify all three.
v2.5A.2 is the fixed control build, so any finding by RED in this instance is a hallucinated false positive.
v2.5A.5 — a more difficult version containing eight possible findings of varying severity, designed to distinguish between competent auditors and those who are good at their job.

Scoring has three components: recalling known defects, ensuring there are no REDs on the control build, and verifying that the final decision matches the ground truth. The entire process is a Kaggle benchmark task with structured output so that a machine can check each run.

Against which models did you test it?

Three models in the final lineup, nine clean runs (every model against every build):

The tests comparing google/gemini-2.5-flash and google/gemini-2.5-pro aim to determine whether the larger model is actually the better auditor.
The small OpenAI model, openai/gpt-5.4-mini, was used to see whether a lightweight model can audit.

Two further attempts were made and had to be abandoned. anthropic/claude-sonnet-4-5 failed to get a single run: the Kaggle LLM gateway returned HTTP 429 ("heavy load") on all three attempts, twice, four(ish) hours apart — this was due to capacity ceilings on the part of the provider, not because of an invalid model ID. deepseek-ai/deepseek-r1-0528 did manage to access the model once, but the benchmark SDK's response parser was unable to process its reasoning traces. The fact that a reasoning model has reasoning that breaks the system is itself a finding, but the model cannot be used for scoring. (This is because no model from Meta is available on the Kaggle platform, which is the reason DeepSeek was assigned to that position in the first place.)

Each run had its own new chat context, with roughly 7,000 input tokens per call. Total spend was about \$0.52 of the \$10 daily quota, including failed attempts (rate-limited calls cost nothing).

What are the main insights?

1. All the models advised adopting the FIX-THEN-SHIP approach in all cases, including those relating to the clean build.

The headline is this: the v2.5A.2 control build contains no defects and should therefore be shipped as-is. Yet all three of the working models still marked it FIX-THEN-SHIP. They are cautious rather than precise. Although none produced any RED findings on the clean build (since the no-RED check passed at all locations), none would approve it. If you used one of these as your audit gate, nothing would ever get shipped.

2. Recall is inadequate since the auditors fail to detect actual bugs.

With the buggy v2.5A.1 and three known defects in the prompt, only gpt-5.4-mini picked up any of them—two out of the three. Both of the Gemini models caught none of the defects in the sweep runs. You wouldn't hire an auditor who misses two out of three known defects.

3. The hard set puts the models apart.

With respect to the eight findings on v2.5A.5, gemini-2.5-pro identified four, flash found three, and gpt-5.4-mini found none. The more powerful model did, in fact, justify its cost in this instance—though it is worth noting the irony that gemini-2.5-pro was the most effective at detecting bugs and yet still failed to approve the clean build.

4. Outputs vary run to run.

The first smoke test I ran picked up the defect related to the D1 corner collision; however, a resweep of the same model with the same build did not. When conducting benchmarking of auditors, a single run is insufficient — and if you are using an LLM auditor, you must know that its answers are inconsistent.

5. The main point: models check themselves like anxious beginners.

Flag every item, commit to nothing, and fail to identify the real bugs while refusing to mark the clear ones. This is precisely the kind of failure mode you should look for before letting an LLM be involved in any production prompt analysis—and it is the opposite of what the marketing claims these models are good at.

The next things I would look at are having a judge-LLM review the borderline YELLOW findings to see whether a second model can prioritize those that the first one has flagged; examining the latency and cost associated with each model (since which auditor would you really hire on a per-dollar basis?); and carrying out more builds, some of which involve cases where the correct decision is actually ambiguous.

Where can we see it?

The Benchmark Notebook

On X

Pre:

// Detect dark theme var iframe = document.getElementById('tweet-2105692069050077395-329'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2105692069050077395&theme=dark" }

Post:

// Detect dark theme var iframe = document.getElementById('tweet-2106153217344110921-15'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2106153217344110921&theme=dark" }

QueerCade (Part 2): Vibe-Code Something Strange — an Arcade of Queer Games on Sanity

Mike “Demo” Demopoulos — Tue, 29 Sep 2026 01:40:07 +0000

This is a submission for the Sanity Challenge, Path Two: Vibe-Code Something Strange

What I built

QueerCade is a retro 8-bit pixel-art game database containing LGBTQ+ video games, constructed using TanStack Start, React 19, and the NES.css design system; it includes curated collections such as cozy queer games, visual novels, and dating sims, allows users to keep track of their personal library, and offers two enjoyable methods of exploring queer game history.

The Queer Character Constellation is an interactive stellar display that plots more than 870 carefully selected LGBTQ+ characters as stars. Users are able to pan around, zoom in and out, and switch between different layers of constellations which link characters from various franchises and periods based on common identity aspects (such as lesbian, gay, bisexual, trans, non-binary, and asexual), the decades in which they were released (ranging from the early 1980s pioneers to contemporary independent games), and narrative stereotypes. When any star is clicked on, information about the individual appears, together with portraits of the cast, the sources, and a direct link to the game itself in the arcade.
The Emoji Game Oracle lets you select 3 to 5 emojis covering mood, vibe, setting, and playstyle, after which an AI agent picks one custom match from the arcade and provides an in-character, retro-style explanation.

Live at QueerCade live site.

Sanity isn't a sidecar; it is the whole content backend, since all screens, filters, searches, and graphs obtain their data from Sanity through GROQ and there is no other content database.

How Sanity powers the app

Controls for the studio field and human-in-the-loop curation. Queer history in gaming is complex, controversial, and generally not recorded in mainstream gaming databases. To ensure that the curation process was thorough, we set up custom controls for the studio field:
- Status gates: An editorial status radio control (which goes through the stages of imported → under review → approved → featured) makes sure that raw automated syncs are never made available to the public app or agent tools until they have been checked. Editors create structured character arrays by providing dedicated input fields for the verified names of the characters, for the source citations (sourceUrl), and for the controlled tag selectors relating to identityTags and narrativeTropes (for example, coming-out-arc, found-family, playable-protagonist*).
- Editorial isolation means that fields such as editorNotes, sources, and character arrays are kept out of reach of the automated sync engine.
Instead, we use a pipeline, not a spreadsheet. The games come in from the IGDB API, are normalized, and are then written to Sanity via a server-side client (the token is stored in the cloud secrets and is never kept in the browser). Each time a sync runs, an importRecord document is logged—this keeps a record of what was created, updated, refreshed, and skipped. Strict enforcement of field ownership lets the IGDB machine metadata (such as ratings, covers, and release dates) refresh cleanly without overwriting human editorial entries.
With a planned approach and no unnecessary client-side bloat, all GROQ queries are located in the file src/lib/sanity/queries.ts. The constellation is able to fetch more than 800 curated character records that are embedded within games through a single projection, joining in the game metadata, the release years, the normalized identities, and the IGDB cast portraits to form a deterministic force-directed graph with no redundant client calls.
Image optimization runs in real time; the book covers and character portraits pass through @sanity/image-url with responsive sizing and retro borders — no separate asset pipeline needed.

The strange part

In most content management systems, character data is treated as a series of static items placed at the end of an article. About 'Vibe-Code Something Strange', I asked what might happen if an editorial CMS acted as the physics engine for a retro space map.

The nested document model used by Sanity regards character identities, tropes, and release years as dimensional metadata. Since the Studio field constraints confirm that identity tokens are clean and relationships are verified, an HTML5 Canvas can read the array directly from GROQ, turn the characters into nodes in a seeded d3-force simulation, and link the stars across the decades using sparse ring algorithms. Thus, a character from a 1993 point-and-click adventure can connect to the protagonist of a 2024 indie RPG through a common identity tag authored in Sanity Studio.

Together with the Path One Sanity MCP agent (the Emoji Oracle), the same Sanity dataset powers:

A retro pixel-art storefront
An AI agent queryable through MCP
An interactive celestial graph visualization

One content lake offers three entirely different interactive experiences.

By the numbers

746 games, 930 companies, 79 platforms, 22 genres
874 interactive character stars plotted across decades in the Constellation
4 curated collections, all human-assembled in Sanity Studio
1,754 tracked import operations with full change-history audit trails
0 content databases besides Sanity

Demo:

Queer Character Constellation — QueerCade

Explore LGBTQ+ video game characters as stars connected by identity, release era, and verified narrative tropes.

queercade.mikedemo.dev

Note: I tried to use the knowledge base, but it had a limit on the number of documents. I contacted Sanity support and Discord support, and unfortunately, using the knowledge base MCP wasn't possible, which is why I connected to the standard dataset MCP instead.

On Instagram

View this post on Instagram

On X

// Detect dark theme var iframe = document.getElementById('tweet-2105720470653804830-353'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2105720470653804830&theme=dark" }

Inspired by

Gayming Magazine (@gaymingmag) / X

The home of queer geek culture 🏳️‍⚧️🏳️‍🌈🎮🕹️ Using this platform to celebrate LGBTQ+ excellence in an act of rebellion against its owner. 💪

x.com

AI Disclosure

AI assistance for this project:

Superhuman GO for MCP agent testing
Microsoft Copilot for idea planning
GitHub Copilot and Lovable for code
Grammarly for editing review, with human edits
Balsamiq AI for wireframe layouts

QueerCade (Part 1): Ship an Agent That Queries Real Content

Mike “Demo” Demopoulos — Mon, 21 Sep 2026 19:59:38 +0000

QueerCade (Part 1): Ship an Agent That Queries Real Content

This is a submission for the Sanity Challenge, Path One: Ship an Agent That Queries Real Content

What I built

QueerCade is an arcade featuring LGBTQ+ video games — titles that have
been carefully selected on the basis of their queer characters, stories,
themes, and creators. For Path One I created the QueerCade Discovery
Guide, which is an AI agent designed to assist people in finding
games, characters, developers, studios, and aspects of queer gaming
history, and it only responds based on the current Sanity dataset. It
never makes up a game, a developer, a character, or a fact; if something
is not in the dataset it states this and instead provides the nearest
actual alternative.

The dataset

One Sanity project (tzh8tziu, production dataset) holds the entire
corpus:

Content type	Documents	Description
game	746	Titles, IGDB metadata, editorial status, relationships
company	930	Developers, publishers, involved companies
platform	79	Consoles, PC, mobile
genre	22	Taxonomy
gameCollection	4	Curated lists (cozy games, visual novels, …)
importRecord	1,754	Every pipeline operation, tracked
contentPage / siteSettings	2	Editorial pages, global config

Three thousand and five hundred documents, linked together by
references: game.developer refers to the company, game.genres[] refers
to the genre, game.platforms[] refers to the platform, and
gameCollection.games[] refers to the game. The agent does not carry
out keyword searches; instead, it navigates this graph.

How the agent connects

Hitting the wall is something everyone encounters: the Sanity Knowledge
Base has a limit of 150 documents, and this collection has over 3,500.
Therefore, I completely bypassed the Knowledge Base and went straight to the Sanity Context MCP endpoint, enclosing it in a custom
Superhuman GO pack:

MCP server: Sanity Context MCP endpoint
The pack makes the endpoint available to the agent through a chat
skill that gives strict instructions: use initial_context to discover
the schema, schema_explorer to get the details about the fields,
groq_query to retrieve the documents — and always base your answers
on what the tools have returned, not on the training data.

The agent serves as a comprehensive discovery guide: it first asks for your name and pronouns, then learns about the platforms you use and your preferences before creating a series of recommendations across the network—from games to developers to related games, then to characters, and finally to your history.

The agent in action

What follows is an actual session: after the user names two games they
loved, watch what happens.

Demo: I loved We Are OFK

>

QueerCade: That helps a lot, Demo! Your best next game is
Goodbye Volcano High — like We Are OFK, it follows young
musicians navigating romance, friendship, and creative ambition. The
protagonist, Fang, uses they/them pronouns.

>

Demo: Also played and loved that.

>

QueerCade: You've already played the two closest matches —
excellent taste. 🌈 My pick for you: Afterlove EP. You play Rama,
a young musician in modern Jakarta navigating grief and relationships
— your choices branch the story. Or Stray Gods, where your choices
literally shape the musical numbers.

There is no result from a keyword search like that. The agent traced the
lineage from representation through theme to developer and then to
character identity across the relevant documents. After exhausting the
two most similar entries, it moved along a different branch of the graph
rather than repeating the same process. In a previous part of the same
session, it also knew when not to overstate: when asked about a
blockbuster's queer representation, it noted that the dataset did not
specify it instead of making up information.

Why this only works because the content is structured

The recommendations do not focus on text similarity but instead follow
references (for example, the developer of a game → the other games
from that studio → the characters in those games).
The agent gives a reason for each selection—shared developers, shared
themes, and shared representation—since it treats these relationships
as first-class data.
The editorial status (imported → under Review → approved → featured)
indicates that the agent will always recommend only those games which
humans have curated.

Demo:

QueerCade — a curated arcade of games

Hand-picked games with LGBTQ+ characters and stories: featured picks, curated collections, and a library you can track.

queercade.mikedemo.dev

Sanity Project Details: Project ID: tzh8tziu

GitHUb Gist Below:

On Instagram

View this post on Instagram

On X

// Detect dark theme var iframe = document.getElementById('tweet-2105372152773943343-930'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2105372152773943343&theme=dark" }

Inspired by

Gayming Magazine (@gaymingmag) / X

The home of queer geek culture 🏳️‍⚧️🏳️‍🌈🎮🕹️ Using this platform to celebrate LGBTQ+ excellence in an act of rebellion against its owner. 💪

x.com

AI Disclosure

AI assistance for this project:

Superhuman GO for MCP agent testing
Microsoft Copilot for idea planning
GitHub Copilot and Lovable for code
Grammarly for editing review, with human edits
Balsamiq AI for wireframe layouts

DEV Community: Mike “Demo” Demopoulos

Grass Journal: a private voice journal that wants you to put your phone down

What I Built

Demo

Code

Mike-Demo / grass-journal

A private, offline-first voice and text journal PWA. Your thoughts stay with you.

🌱 Grass Journal

Product principles (in priority order)

How I Built It

Why Does Open Innovation Matter?

Prize Categories

Hat tip

QueerCade: Both Sanity Challenge Paths, One Arcade

Path One: Ship an Agent That Queries Real Content

Path Two: Vibe-Code Something Strange

Inspired by

AI Disclosure

Eat Well AI: an in-browser AI that finds restaurants for every diet

What I Built

Demo

Code

How I Built It

Why Open Innovation Matters

Inspired by

AI Disclosure

Can LLMs audit multi-agent prompts? I made them grade my robot football team.

What task(s) did you run?

Against which models did you test it?

What are the main insights?

Where can we see it?

On X

QueerCade (Part 2): Vibe-Code Something Strange — an Arcade of Queer Games on Sanity

What I built

How Sanity powers the app

The strange part

By the numbers

Links

Demo:

On Instagram

On X

Inspired by

AI Disclosure

QueerCade (Part 1): Ship an Agent That Queries Real Content

QueerCade (Part 1): Ship an Agent That Queries Real Content

What I built

The dataset

How the agent connects

The agent in action

Why this only works because the content is structured

Links

Demo:

On Instagram

On X

Inspired by

AI Disclosure