DEV Community: Mike Kim

Doorman: my apps' contact form got 23 messages in six weeks, and all 23 were pitches

Mike Kim — Fri, 16 Oct 2026 18:37:43 +0000

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

What I Built

I have three small Shopify apps. Between 29 August and 13 October their listings' contact form and my email got 35 messages: 23 once the repeats and image-only ones are gone, and all 23 were selling something. Installs and reviews "from real store owners" at $30 a store, paid posts in Shopify Discords, UGC videos. One opened "are you the right person in charge of this brand...?", so I answered it. It was a pitch.

The problem isn't the pitches. It's the day a real merchant writes "the cleaner deleted a product I wanted to keep, can I get it back?", and it sits between two messages that begin "I came across your Shopify app and was really impressed".

Gmail already catches most of this. The pitches sent straight to my address mostly went to spam. The nine that came through the app listing's contact form all reached the inbox, because Shopify delivers them inside its own notification email, from its own address. A spam filter sees Shopify; only the words inside are a pitch. That's the inbox Doorman is for: the one behind a listing, where every message arrives wearing the marketplace's uniform.

Doorman sorts a contact-form inbox: customers first, pitches folded away. Drop in .eml files or a Gmail Takeout .mbox, or paste a message, and press Sort. Pitches fold away with the giveaway sentence highlighted; close calls stay on top as "not sure"; nothing is deleted or answered. It runs entirely in your browser: the model downloads from Hugging Face once, and a customer's message, with their name, store and order in it, never leaves the page.

Who would pay for it: anyone whose contact form belongs to a marketplace listing, starting with Shopify app and theme developers. Those pitches can't be filtered upstream, because the marketplace is the sender. A new app lives on its first reviews, and a merchant whose question sat under a pile of pitches is a lost install or a one-star review. The page stays free; what I'd charge for is the version that runs on the Gmail page itself (below).

Demo

Live: doorman.mikey9220.workers.dev. The example is five merchants' questions from the public Shopify forum that the classifier has never seen, and seven pitches from my own inbox (anonymised, and part of its training data). The first sort downloads EmbeddingGemma once (197 MB); then the twelve take about two seconds on my Mac's GPU.

Code

mikey92 / doorman

Sorts the contact-form inbox of a small app or store: real customers in, sales pitches out. Gemma runs in your browser; messages never leave your machine.

Doorman

Your app's or shop's contact form, sorted: customers first, sales pitches folded away. It runs in your browser; nothing you load leaves the page.

Live: https://doorman.mikey9220.workers.dev · Write-up: on DEV · Evaluation: eval/CLASSIFIER.md · Data: eval/DATA.md

In six weeks my three Shopify apps' contact form, and the email behind it, got 23 different messages from 21 senders. All 23 were people selling me something: installs, reviews, a promo post in their Discord. Not one was a customer. The day one is, I don't want it buried under the next "I came across your app and was really impressed".

Load messages (paste one, drop .eml files, or a Gmail Takeout .mbox) and press Sort Inbox. EmbeddingGemma 300M, running in a Web Worker on your GPU, turns each message and each of its sentences into 768 numbers; a logistic regression trained on 245 hand-labelled forum posts and my…

View on GitHub

How I Built It

.eml / .mbox / paste → the text, minus the form's wrapper and quoted replies
→ EmbeddingGemma 300M on WebGPU: the message and each sentence as 768 numbers
→ logistic regression (768 weights, 7 KB of JSON): P(pitch)
→ ≥ 0.8 folded away · 0.5–0.8 "not sure" · below 0.5 customer
→ the most pitch-like sentence quoted on the card

A static site on Cloudflare's free tier; Transformers.js runs onnx-community/embeddinggemma-300m-ONNX (q4). No server.

First try: ask Gemma 3 1B, and read its mind

Last week I ran Gemma 3 1B in the browser, so I asked it to copy the sentence where the sender offers their own product or service, or write NONE.

Gemma 1B doesn't copy. Asked for "word for word", it paraphrases: "OFFER: StartStorez Bundle is a free bundle app" for a message that said "you can give StartStorez Bundle a try". Every quote failed the check.

So I stopped asking it to write anything. For each sentence I asked "In this sentence, is the sender offering the business their OWN product, app, service, agency or help? Answer Yes or No", and instead of reading its answer, read its next-token logits for "Yes" and "No". With an open model you can do that: the generate loop takes a logits processor, and mine only looks.

const peek = (_ids, logits) => {
  pair ??= [logits.data[yes], logits.data[no]];
  return logits;
};
await model.generate({ ...inputs, max_new_tokens: 1, do_sample: false, logits_processor: [peek] });
return pair[0] - pair[1]; // log-odds of Yes over No

The logits told me something the answers never would have: Gemma 1B says Yes to almost everything. On 40 hand-labelled messages, customers scored between −2.3 and 11.6 in log-odds; pitches between 6.8 and 14.9. A merchant asking for "Alerts via email, ideally with an attached CSV or Excel report" scored 11.6, higher than 11 of the 20 pitches. It ranks pitches above customers more often than not (AUC 0.91), but only 9 of 20 pitches beat every customer, and with one forward pass per sentence it took about 20 seconds a message on my Mac's CPU.

What worked: don't ask, measure

A pitch doesn't need to be understood to be recognised. "I came across your app", "I can help you get your first installs", "let me know if you're open to a quick chat": pitches read alike, and an embedding model is built to notice what reads alike. EmbeddingGemma is a quarter of the download, and one forward pass gives me a message's 768 numbers. All I needed was examples to fit a line through them.

Where the examples came from

My inbox had 23 pitches and no customers: the problem, not a dataset. So I went where merchants ask in public: the Shopify Community "Shopify Apps" board. I took the 60 most recently active topics, 637 posts, and read and labelled every one: asking for help, selling something of their own, helping with nothing to sell, or other.

282 of the 637 posts were someone selling their own app or service. 48 of the 60 topics had at least one. One merchant asked for bundle app recommendations "(from shop owners, not app developers!)"; seven of the thirteen replies were from app developers.

Leaving out 150 posts where I couldn't tell whether the account was the app's maker, and keeping one pitch per account, gave 115 merchants asking and 130 pitches. (How it was labelled.)

How well it works

Five-fold cross-validation over the forum posts, split by topic so nothing is ever scored by a model that saw its thread (full report):

Fold away at P ≥	Customers hidden	Pitches folded away
0.5	5 of 115	125 of 130
0.8 (the page)	2 of 115	102 of 130
0.9	0 of 115	79 of 130

The pitches it doesn't fold away aren't lost either: the 28 under 0.8 stay on top, 23 of them marked "not sure" with their most pitch-like sentence quoted. They cost five seconds; a hidden customer costs a sale, which is why the bar is 0.8.

AUC 0.991: pick a random pitch and a random customer, and 99 times in 100 the pitch scores higher. On the same 40 messages Gemma 1B judged, scored by a model trained on the other 205 posts, it's 1.000: the most pitch-like customer scores 0.28 and every pitch is above 0.8. I chose the settings on this table, so read it as a ceiling.

The two customers it would hide are merchants describing their own shop in ad voice ("Award-winning refill shop in Oxfordshire…"). That is a pitch, just not aimed at me, and it's why nothing is ever deleted.

My inbox: a lesson in where training data comes from

Trained on the forum alone, the classifier folded away only 13 of my 23 pitches at 0.8 (22 at 0.5). Cold emails are written differently from forum replies: longer, more flattering, and they end by asking for a call. The fix was to train on them too, and to test it honestly I scored each of the 21 senders with a model trained on the forum and on every other sender's messages. 23 of 23 folded away at 0.8, 19 at 0.9. That inbox has no customers in it, so it's only half the test; the forum table is the other half. The shipped classifier is trained on all 268 messages.

Why Does Open Innovation Matter?

The messages are the private part. A support inbox is customers' names, emails, store URLs and order problems. With an open model in the browser, nothing is uploaded and no server holds anything. "Your customers' messages never leave your machine" is the whole pitch of a product like this, and with a hosted API I couldn't say it.

It's free to run, so it can be cheap to buy. A message takes under a fifth of a second of the visitor's GPU. A hosted API would put a bill on every message, a key behind a server, and a floor under the price.

I could look inside. Reading Gemma 1B's logits is what showed me it was saying Yes to everything, which a chat API's confident "Yes" would have hidden. Open weights also let me train a 7 KB head on EmbeddingGemma's vectors, ship it as JSON anyone can read, and run the same code in Node for the evaluation.

Where a closed model would be better: a frontier model would likely sort these well without a single labelled example. But it would see every customer's message, charge for every one, and I'd still have needed the 245 labels to know how well it does.

My First User

Me, and I'm not counting it: all 23 of my pitches folded away, each sender scored by a model that had never seen them. I'm looking for three app developers to run their own Takeout export through it and tell me what it got wrong; what they find goes in the comments.

What they'll ask next, if my inbox is any guide: "can it run inside Gmail?" That's the Chrome extension: the same model, on the page you already have open.

Prize Categories

Best Use of Gemma: EmbeddingGemma 300M reads every message on the visitor's GPU, with its classification prefix; Gemma 3 1B's open logits showed why asking a small model "is this a pitch?" doesn't work.

Every PDF failed on Windows because of one trailing backslash (and two more Windows text gotchas)

Mike Kim — Fri, 09 Oct 2026 04:10:58 +0000

I build BCD, a hosted remote MCP server that lets ChatGPT and Claude read files and run commands on your own computer. Our logs showed file reads failing far more often on Windows than anywhere else. There were three causes, and you'd never see any of them testing on a Mac.

1. pdf.js and a trailing `\`

We passed pdf.js (pdfjs-dist) its standard font folder like this:

const standardFontDataUrl =
  path.resolve(here, '../node_modules/pdfjs-dist/standard_fonts') + path.sep;

On macOS and Linux that ends in /. On Windows path.sep is \, so it ends in \. pdf.js treats the value as a URL and checks the last character:

function getFactoryUrlProp(val) {
  if (typeof val !== "string") return null;
  if (val.endsWith("/")) return val;
  throw new Error(`Invalid factory url: "${val}" must include trailing slash.`);
}

So on Windows, getDocument() threw for every PDF, whatever its content, and from the outside it just looked like "this PDF can't be read". The fix is one line:

const fontFolderUrl = (folder, separator = path.sep) =>
  folder.split(separator).join('/') + '/';

In Node, pdf.js appends the font file name and hands the result to fs.readFile. Node's fs on Windows reads C:/Users/.../standard_fonts/FoxitSans.pfb with forward slashes just fine. We added a unit test that feeds in a Windows-style path, and a step in our Windows CI smoke test that reads a real PDF.

Lesson: when you append path.sep, check whether the value is used as a path or as a URL.

2. PowerShell writes UTF-16

In Windows PowerShell 5.1, command > out.txt writes UTF-16LE with a byte order mark (FF FE). Our text reader was UTF-8 only and treated any NUL byte as binary. UTF-16 has a NUL after every ASCII character, so those files were all rejected. An AI writing output to a file with PowerShell and then reading it back is a common flow, so this hurt.

Now the first two bytes pick the decoder: new TextDecoder('utf-16le', { fatal: true }) (or utf-16be). When we read the end of a large file, cutting in the middle can split a character, so the window starts after the next line break (0A 00 in UTF-16LE).

3. Excel CSVs in CP949, and Node's `euc-kr` trap

On Korean Windows, Excel saves CSV in CP949. There's a trap here: Node's TextDecoder('euc-kr') is not CP949. It can't decode the extended Hangul syllables, and it doesn't throw. It silently produces control characters:

new TextDecoder('euc-kr', { fatal: true }).decode(Buffer.from([0x8c, 0x63]))
// '\x8Cc'  (wrong, and no exception)
iconv.decode(Buffer.from([0x8c, 0x63]), 'cp949')
// '똠'

What we do now:

If UTF-8 decoding hits an invalid sequence, read the file again in the legacy code page for the computer's language (CP949 for Korean, CP932 for Japanese, CP936 or CP950 for Chinese) with iconv-lite.
If that result contains U+FFFD, it isn't text.
Files with NUL bytes are real binaries and are never retried.
The read reports which encoding it used (encoding: "cp949"), so the AI knows before it writes the file back.

Bonus: classify failures honestly

A file that really isn't text is now recorded as an invalid argument, not a tool failure. If your own bugs and your users' inputs land in the same bucket, you won't see the next bug.

Disclosure: I'm the maker of BCD. It lets ChatGPT and Claude work on your own Mac, Windows or Linux computer: files, commands, documents and a browser.

Letting a team's AI run commands on shared computers: two layers of permissions and an audit log

Mike Kim — Thu, 08 Oct 2026 22:16:41 +0000

Once ChatGPT or Claude can edit files and run commands on your computer through MCP, using it alone is easy. Sharing it with a team raises questions fast:

Who asked the AI to do what, on which computer?
What if a command the AI ran had an API key in it?
Where do you see what someone did after they left the team?

Disclosure: I'm the maker of BCD, a hosted remote MCP server that lets AI apps work on your own Mac, Windows or Linux computer. This week I shipped a team activity log, and these are the decisions behind it.

The setup

Each computer runs a small agent that only opens an outbound connection to a relay. No ports are opened.
AI apps (ChatGPT, Claude, Codex) connect by adding https://bcd.snack-wrap.com/mcp as a connector.
In a team, each member shares computers they paired.

Two layers of permissions

What the computer's owner allows: read / write / run commands / control the screen / clipboard. A new computer starts read-only.
The member's team role: admin (everything, plus managing members), builder (read, write, run commands), viewer (read).

A member gets the narrower of the two. A builder on a computer its owner left read-only can only read.

What the log records

Every call on a shared computer is recorded, including the owner's own:

who, on which computer, through which AI app (ChatGPT, Claude…)
what they did (ran a command, read a file, deleted files…), the result, why it failed, how long it took
the files and folders, web addresses (without their query) and commands the call named
team changes: invitations, joins, role changes, removals, shared computers

Never recorded: typed text, file contents, clipboard contents, output.

Admins filter by member, computer, result and period, search by file path or command, and export CSV. The team owner picks how long entries are kept: 30, 90, 180 or 365 days. Only admins can see the log.

Secrets are masked before anything is stored

Commands an AI runs tend to carry tokens. These are real outputs of the masking code:

curl -H "Authorization: Bearer eyJhbGciOi..." https://api.example.com
→ curl -H "Authorization: *** ***" https://api.example.com

export OPENAI_API_KEY=sk-proj-... && npm test
→ export OPENAI_API_KEY=*** && npm test

psql postgres://me:s3cret@db.example.com/app
→ psql postgres://me:***@db.example.com/app

https://api.example.com/v1/orders?token=abc
→ https://api.example.com/v1/orders?…

Decisions worth stealing

Allowlist the arguments you read. The log reads only named arguments such as path, command and url. Fields like content, text or input are never read, so a new tool can't leak file contents into the log by accident.
Snapshot names. Entries keep the person's email and the computer's name at the time, so they still read correctly after a member leaves or a computer is removed.
Defuse CSV formulas. Cells starting with =, +, - or @ get a leading ', so a spreadsheet never runs them.
Rows, not a wide table. Each entry reads top to bottom: what happened and its result, what it named, then who, where, when. It works on a phone without sideways scrolling.

Try it

One computer stays free; the first month covers 3 computers with no card. Paid plans and the free month can try a team of 3.

👉 bcd.snack-wrap.com

What else would your team need before letting an AI work on shared machines? I'd like to hear it in the comments.

Paper Trail: Gemma writes your walk a field card, then the screen goes away

Mike Kim — Tue, 06 Oct 2026 02:23:27 +0000

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

What I Built

Nature apps have an awkward habit: they get you outside and then ask you to look at them. You lift the phone to identify a bird, the bird leaves, and you're still looking at the phone.

Paper Trail goes the other way. Tell it where you're walking and when. It finds the species people have actually reported there at this time of year, asks Gemma 3 1B, running inside your browser tab, for one line on how to recognise each, and gives you a single page to print: twelve species with checkboxes, a warning where Wikipedia gives a reason ("Toxic: don't taste"), the day's weather, the time to start by to finish in daylight, and a box to sketch whatever isn't on the card. On my Mac the screen part takes about twenty seconds. The phone can stay in your pocket for the rest of the afternoon.

It's for anyone who'd like to know what they're looking at without walking behind a screen: a family ticking boxes on a Sunday loop, a kid who just learned what a towhee is and wants to find another.

Demo

Live: paper-trail.mikey9220.workers.dev

Press See an Example for a finished card straight away. Your own card downloads Gemma 3 1B once (about 0.8 GB). In Chrome on my Mac the first card took 21 seconds of download and 17 to make; every card after that, about 17. Without WebGPU the page suggests quoting Wikipedia instead.

Code

mikey92 / paper-trail

A printed field card for your walk: species people reported nearby, one line each written by Gemma 3 1B in your browser and checked against Wikipedia.

Paper Trail

A printed field card for this week's walk, written by Gemma in your browser.

Live: https://paper-trail.mikey9220.workers.dev · Write-up: on DEV · Evaluation: eval/EVAL.md · Hand review: eval/REVIEW.md

Tell it where and when. It finds the species people actually reported there in past years at this time of year (iNaturalist), reads what each one looks like (Wikipedia), and has Gemma 3 1B, running in a Web Worker on your own GPU, write one line on how to recognise each. Every line is checked against the Wikipedia sentences it was written from before it can reach the card; a line that fails is retried once with the rejected words named, and if it fails again the card quotes Wikipedia instead. You get one page with checkboxes, a box to sketch in, the weather and the time to start by to finish in daylight. Print it and put the phone…

View on GitHub

How I Built It

where + when → iNaturalist: species reported within a few km, this month in past years
             → pick 12: birds, plants, a fungus and an insect, most-reported first
             → Wikipedia: the Description sentences about colour, shape, texture, sound
             → Gemma 3 1B in a Web Worker: one tip each
             → check against those sentences: fail → retry once → quote Wikipedia
             → Open-Meteo weather → one printable page

There is no backend: the page is static files on Cloudflare's free tier, and Gemma runs on your GPU. Transformers.js loads onnx-community/gemma-3-1b-it-ONNX-GQA (4-bit, 763 MB) on WebGPU, and decoding is greedy, so the same sentences always produce the same tip.

A 1B model is a careless witness

My first prompt asked for "ONE sentence of at most 15 words that tells a walker what to look or listen for", using "only words and facts from the source". I ran it on six places on three continents (72 species, the same inputs every time) and read every answer. Gemma 3 1B writes fluent, plausible tips, and gets the details wrong:

Low smartweed: "Look for hairy stems…". Wikipedia: "The hairless, branching stems…"
Great blue heron: "a rusty gray head". The neck is rusty-gray; the head is paler.
A bracket fungus: "…and a mild taste". Wikipedia says so. No card should send anyone to taste a wild mushroom.
Toyon, a shrub: "listen for the cheerful toyon song", borrowed from the robin in my example prompt.
Common hawthorn: "Dark red fruit persists for 107.3 days, bearing 2.8 seeds." True. Useless on a walk.

What makes this fixable is that every tip is written from a handful of sentences I already have, so every tip can be checked against them. checkTip() in src/ground.ts passes a tip only if:

every content word is in the source, after crude stemming (lobed and lobes, reddish and red); pointing words like look and observe are free;
every colour, tone or pattern sits next to the same part in the source: within eight words, with no other colour in between. That catches the heron's rusty gray head, and green spores on sulphur tuft, whose gills turn green "as the blackish spores develop";
there are no numbers, not even true ones, and nothing about taste;
"listen for" comes with something to hear: a call, a song, drumming.

expect(checkTip("Look for yellow gills and green spores.", tuft).unsupported).toEqual(["green spores"]);

A failed tip gets one retry that names the rejected words (The source does not say: "gray leaves"…). If that fails too, the card quotes the article's most visual sentence in quotation marks. Every line on a card is either checked or quoted.

Four prompts, the same 72 species

Prompt	What changed	Passed first try	Printed, with one retry	Quoted instead
v1		3 (4%)	31	41
v2	"Look for" or "Listen for"; a bird and a plant as examples; observe allowed; no numbers	47	50	22
v3	No taste; "listen" needs a sound; no sentences comparing with another species; colour within eight words of its part	46	49	23
v4	"Keep every colour with its own part"; no other colour in between	29	39	33

v1's 4% wasn't Gemma being wrong 96% of the time: most first tries began "Observe the…", and observe isn't in any Wikipedia description. Reading the rejections, not just counting them, found that and most of the other fixes (full report). v4 prints fewer of Gemma's lines than v3 on purpose: I read every line both printed, and v3 had 12 wrong where v4 has 5. A quote is plain, but it's true.

What the check can't see

I read all 39 tips Gemma wrote in the final run next to their sources (every verdict): 29 right, 5 clumsy (glabrous, sori), 5 wrong. Two of the wrong ones:

Wood duck: "listen for a rising whistle from the female". The rising whistle is the male's call.
Toyon: "red fruits developing in December". They develop in August or September and ripen in December. That one is on the example card above; I left it there.

Every word is in the source and every colour is next to its part. What's wrong is whose or when, taken from the next clause, and a word-level check can't parse who a clause is about. It narrows what can go wrong from anything a model can imagine to true words put back together wrong, while the species list, warnings and weather stay plain data. A third was my fault, not Gemma's: the lyrebird article's tail section opens with "Adult males have tails up to 70 cm (28 in) long", my filter dropped that sentence for its measurement, and Gemma never learned whose tail had "two silvery median feathers".

Gemma 3 270M, a third of the download, isn't the default for a measured reason: on the same 72 species, one of its tips passed. It mostly copied the prompt's plant example onto everything ("bright white bark peeling in papery strips" for a sparrow and a hawk), and the check caught each one.

One deploy surprise

Everything worked on localhost; on the live site the model never loaded. Hugging Face answers 404, without a CORS header, to any request whose Referer is a *.workers.dev page (pages.dev and localhost are fine; I checked with curl). The page fell back to quoting Wikipedia, as designed, which is why I nearly missed it. The fix is one line in public/_headers: Referrer-Policy: no-referrer.

Why Does Open Innovation Matter?

It costs nothing to run, so it can stay free. A card is up to two dozen generations. On a hosted API that's a bill per card and a key to hide behind a server; here the model runs on the visitor's GPU and the site is static files.

Your location stays yours. The model never sees where you are, only Wikipedia sentences. A location from your device is rounded to about a kilometre before it goes to iNaturalist and Open-Meteo.

I could see and steer every step. Open weights let me run the same model, prompt and decoding in Node for a reproducible evaluation; for the example card it wrote the same twelve lines as the browser on WebGPU, but for one word. Retries are free, so being strict is free.

Where a closed model would be better: the writing. A frontier model would write livelier tips with fewer retries, but it would still need the same check, and it would put a server, a key and a bill between you and the walk.

The data is open too: iNaturalist's observations, Wikipedia's descriptions (CC BY-SA) and Open-Meteo's forecasts (CC BY). Paper Trail is glue and a small model on top of other people's open work.

Prize Categories

Best Use of Gemma: Gemma 3 1B writes every tip in the visitor's browser on WebGPU, with no server, and most of this post is what it took to print a 1B model's sentences.

Gate Check: can this power bank fly? An agent that knows when airlines and regulators disagree

Mike Kim — Fri, 02 Oct 2026 09:27:51 +0000

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

What I Built

Gate Check answers a question people get wrong at the gate every day: can this power bank come with me, and what am I allowed to do with it on board?

The rules changed fast. On 27 March 2026 ICAO limited power banks to two per passenger and banned recharging them on board. Hong Kong applied that the next day, Korea from 20 April, Japan from 24 April. Emirates already allowed only one power bank and banned using it. Lufthansa Group, EVA Air, Singapore Airlines and Qantas each picked their own dates and wording. IATA's 2026 guidance lists power banks of 100–160 Wh as forbidden, while ICAO's addendum still allows them with the airline's approval. And the copies go stale: a 2025 Korean government page still says you may bring five, and Incheon Airport's 2025 press release converts 100 Wh to 20,000 mAh at 5 V, while the ministry and the airlines use 3.7 V (about 27,000 mAh).

So "can I bring my 27,000 mAh power bank?" is not a search problem. You have to:

convert mAh to watt-hours,
find every rule that applies to this trip: each airline, each departure country, and the worldwide baseline,
place the battery in each rule's watt-hour bands and count limits, and
let the strictest rule decide, while keeping track of which page says what.

Gate Check does steps 1 to 4 in code over structured content in Sanity, and an agent uses a Sanity Knowledge Base to explain the result and the disagreements behind it.

Two 27,000 mAh power banks, Korean Air then Emirates, leaving Korea: not allowed. Emirates allows one, and Gate Check quotes both Emirates pages that say so.
One 30,000 mAh power bank (111 Wh) on Asiana from Seoul: needs airline approval, because it is over 100 Wh and up to 160 Wh.
Two 20,000 mAh power banks on Korean Air from Seoul, asked in plain English: you can carry them, but not use them. The agent explains that Korean Air and Korea's transport ministry ban using power banks in flight, while ICAO only says they "should not" be used.

Demo

Live: https://gate-check.mikey9220.workers.dev (no login)

Quick check runs the rule engine alone, with no AI: capacity, count, airlines and departure countries in; one card per rule out, strictest first, with the exact wording behind each finding and a link to the page it came from.
Ask the agent takes a question in plain language and shows its work as it goes: each tool call, then the rule engine's verdict, then the answer, with every page it rests on.

Code

mikey92 / gate-check

Can this power bank fly? Airline and regulator power bank rules as structured content in Sanity, evaluated in code, served through Sanity Context MCP.

Gate Check

Can this power bank fly? An agent that answers from airline, regulator and IATA rules kept as structured content in Sanity, evaluates them in code, and shows the exact wording behind every verdict, including where the sources disagree.

Try it: https://gate-check.mikey9220.workers.dev

Power bank rules changed fast in 2025 and 2026. ICAO limited power banks to two per passenger and banned recharging them on board from 27 March 2026; Korea, Japan and Hong Kong followed with their own dates; Emirates allows one and bans using it; IATA's 2026 guidance lists 100–160 Wh power banks as forbidden while ICAO still allows them with the airline's approval. News articles, airport pages and travel blogs restate all of this and go out of date. A traveller holding a "27,000 mAh" battery has to convert it to watt-hours, find every rule that applies to every leg, and pick the strictest.

Gate Check does…

View on GitHub

How I Used Sanity

The content model

Three document types:

authority: an airline, regulator, airport operator or industry body, with its country and codes (Asiana is OZ, Asiana and 아시아나). There are 32.
source: a captured copy of one page: URL, kind (official, news or third-party copy), language, capture time, an excerpt, and the statements quoted from it. There are 60, in English, Korean, Japanese and Chinese.
batteryRule: what one authority says, in fields code can evaluate. There are 30.
- scope: an airline's own rule, a departure country's rule, domestic flights, the worldwide baseline, or advisory guidance
- limits: freeMaxWh, approvalMaxWh, maxWh, freeMaxCount, approvalMaxCount, totalMaxCount
- onboard: checked baggage, using it in flight, recharging it, the overhead bin, keeping it visible, terminal protection, a readable label, a certification mark, each with a value such as forbidden, discouraged or required
- status (confirmed, disputed or unverified) and a note that explains a disagreement
- quotes[]: for each field, the exact wording and a reference to the source it came from (211 in all)

A rule may only state what a source says. The build script copies every quote's text from the captured page, so it is never typed twice, checks every reference, and fails if a rule sets a limit or an on-board condition without a quote. That check found 28 gaps in my own data. It also fails if two documents share a title, because the Knowledge Base cites documents by title.

Two Context MCP endpoints

gate-check-data, GROQ mode, over the whole dataset. The rule engine fetches every rule that applies to a trip in one GROQ query (airline rules matched by name or code, departure-country rules by country, worldwide rules always), with each rule's quotes and their sources. User input only reaches GROQ as JSON-escaped string literals.
gate-check-rules, Knowledge Base mode. The Knowledge Base reads the same dataset through a custom GROQ projection: 30 rules and 60 pages, 90 documents within the 150 budget. The projection flattens Portable Text with pt::text(body) and keeps provenance (kind, language, capture date, authority) next to the text, so entries can tell an official page from a news report or a copy.

The Knowledge Base

Sanity Context organised the 90 documents into 22 entries: airlines by region, each regulator, the ICAO baseline, IATA's guidance, airport screening, entries across all authorities on in-flight use, storage, watt-hour limits and terminal protection, and an entry for conflicting and superseded rules.

Each build files the conflicts it finds as issues, with both claims and their sources side by side. Working through them was the most useful part of the project:

Real errors became standing instructions. An entry spelled Air Canada's banned Anker model A1682; the page says A1681. Another said ICAO bans power banks from overhead bins; the addendum says nothing about overhead bins, and the claim had come from a travel blog. Korea's 2025 limit of five power banks lost to the 2026 limit of two.
Differences between authorities were dismissed. ICAO's "should not use" and an airline's ban are both right, each for its own flights. The FAA's "no quantity limit" and an airline's cap of two are both right too.
Facts the entries kept getting wrong became manual instructions. EASA has not banned using power banks: its bulletin is information only, and its press release says "not forbidden but strongly discouraged". In Japan, five of the seven rules in the ministry's leaflet carry penalties, and "don't use it to charge devices" is not one of them. And ANA's page sets no rule on using power banks in flight, but an entry that covered JAL and ANA together summed both up as banning it.
The purpose carries the policy for everything else. Rules are never merged; every limit is attributed to its authority and dated; superseded rules are labelled as previous rules; and for 100–160 Wh power banks, both ICAO's and IATA's positions are reported.

No issue is left pending: each one was resolved or dismissed, and every future build keeps those decisions.

The agent

A Cloudflare Worker runs a tool-calling loop on GPT-5.5, on my ChatGPT plan through a small relay on my machine (chatgpt.com refuses calls from Workers); if the relay is down, it runs on Workers AI (Nemotron 3). Its tools:

check_power_bank: the rule engine. It converts mAh to Wh, evaluates every applicable rule and returns the verdicts. The model is told never to convert units or compare limits itself.
find_rules: one authority's rules with every quote, from the GROQ endpoint.
compare_rules: one on-board condition, such as the overhead bin, across every airline and regulator, for questions like "which airlines ban…". One GROQ query instead of six entry reads.
search_entries and read_entries: the Knowledge Base, through knowledge_base_search and knowledge_base_read, with the outline from initial_context in the system prompt.
run_groq: read-only GROQ, as a last resort.

The model never writes a URL: the Worker maps the documents each Knowledge Base entry cites, and the source of every rule it evaluated, to their pages, official pages first. The quick check calls the same check_power_bank function with no model at all, so a verdict never depends on the model.

The Worker streams each tool call and the rule engine's verdict to the page while the model is still writing, and keeps finished answers in Workers KV, so a repeated question answers at once.

I checked it with 20 varied questions against the dataset: every verdict matched, and the slips I found (a missed list of banned models, ICAO's "must not be recharged" softened into a recommendation) became rules in the prompt.

Sanity Project Details

Project ID: nkpgzr3t
Dataset: production (public)
Every rule with its quotes, as a public GROQ query
Context MCP endpoints: gate-check-rules (Knowledge Base mode) and gate-check-data (GROQ mode)

Rules are a snapshot from 2 October 2026. Always check with your airline before you fly.

I let ChatGPT on my phone work on my Mac: a remote MCP setup

Mike Kim — Thu, 01 Oct 2026 04:11:30 +0000

I kept asking ChatGPT to "clean up my Downloads folder" and getting a nice list of steps back. What I wanted was for it to just do it, on my Mac, even when I'm not at the desk.

So I built BCD. Disclosure up front: I'm the maker. This post walks through how the setup works, what it can and can't do, and the safety model, so you can decide if it fits.

How it works

BCD has two parts:

A small agent on your Mac. It connects out to a relay over a WebSocket. Nothing listens on your network and no ports are opened.
A hosted remote MCP server at https://bcd.snack-wrap.com/mcp. You add it to ChatGPT or Claude as a connector, sign in, and the AI can call tools that run on your Mac.

Because the AI app talks to the hosted server, it works from the ChatGPT or Claude app on your phone too. The Mac does the work.

Setup (about 5 minutes)

Create a free account at bcd.snack-wrap.com.
On the Mac, paste one line into Terminal:

   curl -fsSL https://bcd.snack-wrap.com | bash

Then click Approve in the browser tab it opens. The agent runs as a login service, so it reconnects after restarts and sleep. You don't keep a Terminal window open.

Add the connector:
- ChatGPT: Settings, Apps, Advanced settings, turn on Developer mode, then create an app with the address https://bcd.snack-wrap.com/mcp.
- Claude: Settings, Connectors, Add custom connector, same address.
- Claude Code / Codex: the installer offers to add it for you.

Things I actually use it for

These are the prompts I send most, in plain words:

"Sort my Downloads folder by file type and tell me what moved."
"Read the three meeting-notes PDFs on my Desktop and list the to-dos nobody closed."
"Compare September and August sales in sales.xlsx by product, without changing the file."
"Cut 0:20 to 0:32 of this video into a 9:16 clip with a title." (It edits on the Mac with AVFoundation, no ffmpeg needed.)
"Build my iOS app and upload it to TestFlight." (Handy from the phone when you're away.)

Long jobs keep running if the chat connection drops, and the AI can check the outcome of a call whose answer got lost instead of running it twice.

Safety model

Giving an AI your computer deserves some care, so the defaults are conservative:

A new computer starts read-only. The AI can look but not change anything.
Writing files, running commands, screen control and clipboard are separate switches you turn on per Mac in the dashboard.
File changes the AI makes can be listed and undone.
BCD doesn't store your file contents. When the AI reads a file, the content passes through the relay in memory to your AI app.

Limits

Mac only for now. Windows has a waitlist.
You need an AI app that supports custom connectors (ChatGPT developer mode, Claude custom connectors, Claude Code, Codex).
One Mac is free with no monthly tool-call quota. New accounts get the 3-Mac plan free for a month, no card.

If you try it, I'd like to hear what you wanted the AI to do on your computer and where it got stuck. Example prompts are here: bcd.snack-wrap.com/prompts.

DEV Community: Mike Kim

Doorman: my apps' contact form got 23 messages in six weeks, and all 23 were pitches

What I Built

Demo

Code

mikey92 / doorman

Sorts the contact-form inbox of a small app or store: real customers in, sales pitches out. Gemma runs in your browser; messages never leave your machine.

Doorman

How I Built It

First try: ask Gemma 3 1B, and read its mind

What worked: don't ask, measure

Where the examples came from

How well it works

My inbox: a lesson in where training data comes from

Why Does Open Innovation Matter?

My First User

Prize Categories

Every PDF failed on Windows because of one trailing backslash (and two more Windows text gotchas)

1. pdf.js and a trailing \

2. PowerShell writes UTF-16

3. Excel CSVs in CP949, and Node's euc-kr trap

Bonus: classify failures honestly

Letting a team's AI run commands on shared computers: two layers of permissions and an audit log

The setup

Two layers of permissions

What the log records

Secrets are masked before anything is stored

Decisions worth stealing

Try it

Paper Trail: Gemma writes your walk a field card, then the screen goes away

What I Built

Demo

Code

mikey92 / paper-trail

A printed field card for your walk: species people reported nearby, one line each written by Gemma 3 1B in your browser and checked against Wikipedia.

Paper Trail

How I Built It

A 1B model is a careless witness

Four prompts, the same 72 species

What the check can't see

One deploy surprise

Why Does Open Innovation Matter?

Prize Categories

Gate Check: can this power bank fly? An agent that knows when airlines and regulators disagree

What I Built

Demo

Code

mikey92 / gate-check

Can this power bank fly? Airline and regulator power bank rules as structured content in Sanity, evaluated in code, served through Sanity Context MCP.

Gate Check

How I Used Sanity

The content model

Two Context MCP endpoints

The Knowledge Base

The agent

Sanity Project Details

I let ChatGPT on my phone work on my Mac: a remote MCP setup

How it works

Setup (about 5 minutes)

Things I actually use it for

Safety model

Limits

1. pdf.js and a trailing `\`

3. Excel CSVs in CP949, and Node's `euc-kr` trap