DEV Community: MANIFESTA

I built a ministry that loses your form on purpose

MANIFESTA — Sun, 04 Oct 2026 23:25:59 +0000

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

What I Built

The Ministry of Approvals. You file anything (a meme, a name for your cat, a plan, a complaint about the plan) and it walks a corridor of three departments staffed by AI clerks with opinions, lands on a human Minister's desk, and if it survives it goes on a public wall as a certificate with stamps on it.

The Department of Pedantry finds the one thing you forgot and cites a regulation it made up on the spot. The Department of Rubber Stamps approves everything and says something that proves it did not read your form. The Archive loses every third form and hands you a receipt explaining where it probably went. Then the Minister (me, allegedly a human) has one hour to rule. If I sit on it, the Department of Delays sends it back to the Archive, which loses it again. 💀

I run communities for a living and I have spent years waiting for someone with a stamp. This is that feeling, as a website, with the stamp physics done properly. It is cool and also slightly cursed 🫡

Under the paint: the whole corridor is one Sanity Workflows definition that lives in the same dataset as the forms. Every step you see on the site is the workflow being read back. The clerks are Agent Actions with personalities stored as content, so you can slide a temperament from "rubber stamp" to "stickler" in Studio and the prompt rewrites itself. Their portraits were painted by Agent Actions too, from their own job descriptions. The Minister rules from a back office built with the App SDK inside the Sanity Dashboard.

Demo

Live: https://ministry-of-approvals.vercel.app
Studio: https://ministry-of-approvals.sanity.studio (login walled, so the Studio screenshots below are what it looks like inside)

A form gets filed, Pedantry returns it, I fix it, it walks Rubber Stamps and the Archive, the Archive loses it, it does the whole lap again and lands on the Minister's desk with a deadline. No cuts:

Then the ruling, from the back office in the Dashboard. I take the file, approve it with a note, and the audit trail fills up live: approve, issue, certificate, Discord announce, framed, on the wall. About 15 seconds. 🔥

The certificate is a real PNG and the Ministry posts it to Discord the second it is issued:

Some stills, because the GIF is big:

If you file a form yourself: the Archive loses serials divisible by three. Check the counter on the Front Desk and pick your moment 👀

Code

https://github.com/A1VARA5/ministry-of-approvals (MIT)

Four folders. studio is Studio 6.9 with the Workflows plugin, a temperament slider, a stage badge and a portrait action. workflows is the definition, the clerk handlers, the Sanity Functions runtime and 14 bench tests. app is the App SDK back office. web is the Astro 7 site with the certificate renderer.

My Build Process

Everything below is what I decided and what broke, in the order it happened. The dated log is in the repo.

The engine is a library, not a service

The first thing I got wrong was in my head before I wrote a line. I assumed a workflow with an AI step would just run. It does not. Sanity Workflows is early access (0.33.0 landed the day the challenge opened) and the engine is a library. Nothing moves on its own. An AI clerk is an effect that some runtime you own has to pick up and drain. Once that clicked, the whole architecture fell out of it: a Blueprint with a robot token and a Document Function that wakes up whenever a run gains an unclaimed effect and drains it. One drain walks a form through every automated department. The first full pass took about 20 seconds from resubmit to the Minister's desk, and I sat there watching the status page like it was a football match.

The schema, and what is on purpose not in it

Five document types. submission is what the citizen wrote and nothing else. There is no status field on it. Where a form is lives in the workflow instance document next to it, and the public status page is one GROQ query on that instance. department is a stage described as content: name, motto, clerk, stamp colour. Renaming the Department of Pedantry is an edit, not a redeploy. clerk is an AI personality stored as content: a system prompt, a temperament number, a catchphrase, a portrait. certificate is only ever written by an effect handler and copies the clerks' remarks in as stamps, so the wall survives even if someone deletes the run. receipt is keyed on the effect key, so a retried handler cannot issue two receipts for one loss. I learned that one the boring way.

The workflow

Seven stages. Each department is an activity with a trigger that queues the clerk effect, a second trigger that marks it done when the effect settles, and a third that marks it failed. Transitions branch on typed effect outputs: Pedantry returns complete: boolean, the Archive returns lost: boolean. The Minister's desk is the human stage: approve with a note, reject with a reason, refer to a department. All of those are actions with params, and the site, the back office, the CLI and the Studio plugin fire the same actions, so there is one audit trail whoever pressed the button.

The bit I am most pleased with is the Department of Delays. The Minister's desk has a stage scoped deadline field seeded by a GROQ query value (string(dateTime(now()) + 3600)) and a trigger with when: '$fields.deadline <= $now'. When a tick finds the deadline gone, the file goes to the Archive flagged overdue, and the Archivist loses it every time and says so on the receipt. A Scheduled Function ticks every open run once an hour (that is the fastest my plan allows), and the status page ticks a file while someone is looking at it, so nobody has to wait for the clock in a demo.

I proved it on myself while writing this. Serial 6 ("Declare the office plant a senior colleague") reached my desk at 13:41:51 UTC. I ignored it. At 14:42:08 the next tick sent it to the Archive, which lost it for the second time: "The declaration and its duplicate probably drifted to Shelf F, resigned, behind the expired flora certifications after the Minister let the deadline pass. The Minister may note that the plant remains senior while the papers remain unpromoted." By 14:42:27 it was back in Pedantry for a third lap. I got roasted by my own Archive 💀

Guards freeze the form's text and block deletion while a department holds it. Studio greys the buttons out and names the workflow as the reason. I did not write that UI, the plugin did, and it is the best free feature in the whole thing.

The clerks

Each clerk handler loads its own clerk document and calls Agent Actions with the form passed as a GROQ parameter, so the model sees title, kind, body, citizen, serial and amendments, nothing else. The personality is the document's systemPrompt. Pedantry on a lunch request: "Add the filing reference number, as required by Regulation 8 subsection 3." The Archive, losing a meme about a printer: "It probably slipped behind Shelf M, resigned, where duplicate meme submissions and printer evidence wait without ambition." I did not write those lines and I would not change a word 😂

A clean pass is three Agent Actions calls, one more each time you get returned, two more each time the Archive loses you. The three portraits cost three image credits and about 40 seconds each. Ms. Regulation Ona got a red pen without being asked.

The back office

An App SDK app deployed into the Dashboard. The corridor as a board (useWorkflowInstances, live: file a form on the site and it appears in the Pedantry column without a reload), one file open at a time with the workflow diagram, the remarks, the Minister's buttons, a "take this file" button and the audit trail. A staff register edits the clerks' prompts and temperaments with useEditDocument and publishes them.

What broke

The peer dependency wall. Workflows 0.33 peers on @sanity/ui 3. Every Studio from 6.10 up ships @sanity/ui 4. I checked each minor. 6.9.x is the last line on ui 3, so the Studio is pinned to 6.9.2 with auto updates off. Then the App SDK quickstart scaffolded SDK 2 and Workflows wanted 3.1, and the 6.9.2 CLI never got the app past the Dashboard spinner because that CLI predates SDK 3 by two weeks. The app uses a newer sanity for the CLI only. And @sanity/workflow-components declares types it does not ship, so there is a 20 line local declaration file sitting there judging me.

My own design mistake. Version one had the website write the citizen's amendment onto the submission document and then fire resubmit. Firing the same action from the CLI got the form rejected again, because the CLI never wrote the document. Fixed by making the workflow own it: resubmit parks the amendment on workflow fields with fieldRead ops, and the Pedantry handler files it onto the document and clears the fields. Every caller behaves the same now. That is the entire point of the tool and I had to trip over it to get it.

The hook that hung the Dashboard. useWorkflowSession from @sanity/workflow-sdk hung the app iframe for every real run I tried. The top frame stayed alive, the iframe never painted again. I bisected with checkboxes: still hung with the diagram, the actions, the assignee picker and the history all switched off. The same engine evaluates the same run in 350 ms in Node, and the Studio plugin's own session view works on it. I could not get the iframe's console, so I went around it: the run is a document, so the file view uses the App SDK's own useDocument on it and calls engine.evaluate and engine.fireAction directly. It works. It is not the adapter's intended path, and if someone from Sanity reads this, I would love to know what I did wrong. Later the AssigneePicker hung the frame too when wired to engine.editField, so it is now a plain "Take this file" button. Honest limit: this is the part of the build I understand least.

The test that caught a real bug. I wrote 14 tests on @sanity/workflow-engine-test, which runs the real engine in memory with a clock you control. One of them approved a file without a note. It threw: field.set refuses an undefined param. The back office let you submit an empty note. It is required now. Second surprise: the deadline query value resolves on the in memory lake's wall clock, not the bench clock, so the Delays test runs from the wall clock and advances from there.

Event delivery is usually 4 seconds and once it was 3 minutes. During the recording one form sat in Pedantry for three minutes before the Document Function event arrived. So the status poll now drains any effect nobody has claimed for 30 seconds. Both runtimes claim under a lease, so they never run the same clerk twice, but I would rather the site did not have to do this at all.

Screenshots froze my own site. The page texture was a live feTurbulence SVG filter and every stamp had an feTurbulence mask. Every capture timed out. I pre rendered both to PNG tiles and dropped the rotations on anything with inputs. Instant again. Live SVG filters as textures are a repaint tax, noted for life.

Small ones: Astro's CSRF check refuses a POST without an Origin header (correct, and it bit curl). Guard names must be unique per definition, so they are suffixed by stage. satori's yoga and harfbuzz wasm and resvg's wasm all had to be added to the Vercel adapter's includeFiles before the certificate PNG stopped 500ing in production.

The visual pass

The first version looked like every AI made bureaucracy page: cream paper, a serif, a list. I would have scrolled past it myself. So I wrote a short design spec (the Ministry is a real building and you are holding real paper; references: Wes Anderson title cards, 1970s ministry forms, rubber stamp physics, diploma engraving) and rebuilt it. A plaster corridor with SVG doors drawn from the department documents, a paper sprite that slides to the current door, doors stamped SEEN after each visit, ink textured stamps that slam in on state changes, a filing cabinet for the lost receipts, certificates in crooked brass frames. Then a second pass because the type was too small and the steel looked cheap. It still might. Tell me.

Numbers

7 stages, 3 AI clerks, 3 Agent Actions calls per clean pass, 2 Sanity Functions, 14 tests in 0.6 seconds, 4 lockstep Workflows packages, 1 Studio minor pinned, 3 portraits, 1 hook I never fixed, 1 bug the tests caught before anyone else could, 8 forms filed in production so far, 3 losses, 1 of them mine.

Sanity Project Details

Project v6745vem, dataset ministry. The workflow definition (sanity.workflow.definition) and every run (sanity.workflow.instance) are documents in that dataset next to the submissions, departments, clerks, certificates and receipts. Studio is at https://ministry-of-approvals.sanity.studio, members only, with the Workflows tool in the toolbar. The back office is an App SDK app in my Dashboard, so you get it on video rather than a link.

Credits

Sanity's Workflows, App SDK, Agent Actions and Functions docs, and the AI content pipeline cookbook, whose effect handler shape mine follows. Fonts: Fraunces, Special Elite, IBM Plex Sans. satori and resvg for the certificate PNG. The Archivist's excuses are the model's own.

If you file a form and the Minister is slow, that is me, and the Archive already has it. 🫡

sanitychallenge #devchallenge #buildinpublic

Bot Lawyer: an agent that knows which of Discord's own pages is lying

MANIFESTA — Sun, 04 Oct 2026 23:25:51 +0000

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

What I Built

On June 10, 2026 Discord changed the rule every bot developer hits first. The privileged intent threshold went from "100 servers" to "10,000 unique users", verification got split from intent review, annual reapplication appeared, and about half of Discord's own pages got updated. In my 2026-09-19 snapshot the application flags table still says 100 servers, and the gateway page says 10,000 users at the top of a section and "after your app is verified, you can apply" 25 lines lower. Same site, same day, two rules 👀

I build and run communities for a living, developer communities included, and I build my own bots and tools for them because the ones I want never exist. So I have been on both sides of this: the mod who has to explain to a dev why their bot got denied, and the dev reading the old page while the rule changed underneath me. There is a specific feeling when a support article, the API docs and a Discord staff comment on GitHub all give you a different number and you have 100 servers waiting. Bot Lawyer is the lawyer I wanted at 2am that night, minus the invoice 💀 You tell it your situation (users, servers, which intents, verified or not), it rules yes, no or depends, quotes the page verbatim with the URL and the effective date, and when two pages disagree it shows both sides and says which one it applied. It has a "Rule as of" date, so the same question as of 2026-05-01 and today gives two different rulings, both cited. It runs as a web app and as a real Discord app with a /ask command, and there is a public ledger of all 11 contradictions I found in Discord's docs.

It also does the thing people in my DMs actually ask for every week, which is never about intents: give it a server type and it proposes the whole channel structure with the emoji and separator naming people use (👋┆welcome, 📢┆announcements, 🔴┆live-streams), category headers, and every Discord constraint respected (1 to 100 characters, 50 channels per category, lowercase with no spaces for text channels). It says which parts are Discord rules and which parts are community taste, because it has both on file. Same for a welcome message or a rules post: you get a copyable block that renders correctly, with a character count against the 2000 limit.

Demo

Live: https://bot-lawyer.vercel.app

If you want the five minute version:

Ask "My bot is in 90 servers with about 4,000 users, do I need Message Content approved?" It says no, the threshold is 10,000 unique users since 2026-06-10, and under the answer you see the old 100 servers rule struck through with its dates.
Set "Rule as of" to 2026-05-01 and ask about 120 servers. Now it says yes, and cites the rule that was in force from 2020-10-27 to 2026-06-09. Same bot, same data, different law.
Ask "Is retry_after in seconds or milliseconds?" and watch it quote both pages with dates and pick one (C5 in the ledger).
Ask for a welcome message for your gaming server. You get one copyable block and a character count against the 2000 limit, nothing else.
Ask for channel names for a crypto community server: welcome, rules, announcements, live streams, general chat, trading, memes. You get a category layout with emoji, separator and lowercase names, and a line per constraint saying whether it is a Discord rule or just how people do it.
Ask your own thing. Nothing is precomputed, every answer is a live GROQ query plus a knowledge base read.

Discord: the app is called BOT LAWYER, command /ask question:<...> as_of:<YYYY-MM-DD>. HTTP interactions endpoint, no gateway, no intents, so the bot obeys its own rulings. Add it to any server you own with this link and run /ask (global commands can take up to an hour to show up after install): https://discord.com/oauth2/authorize?client_id=1550945390789140661&scope=bot%20applications.commands&permissions=2048 . It only needs Send Messages. Counsel does not read replies, use /ask again.

Ledger: https://bot-lawyer.vercel.app/contradictions

Code

https://github.com/A1VARA5/bot-lawyer (MIT). Schema in studio/, seed generator and validator in seed/, the Next.js 16 app in web/, all 40 eval questions with grades in eval/, the contradiction file in research/. The README has the commands to run it yourself.

How I Used Sanity

I started by collecting Discord's public pages into a dated snapshot: the developer docs (they serve markdown on purpose and the source repo is MIT), the two help centers through Zendesk's public JSON API, the legal pages, and the discord-api-docs change log and issues. Snapshotted, not live, so the demo does not shift under you if Discord fixes a page next week; the snapshot stays out of the repo. Then I read all of it and wrote down every place two pages disagreed. That became research/CONTRADICTIONS.md, eleven of them, each with both quotes and both URLs. I have moderated arguments between humans for years and this was worse, because both sides are the same company and neither one shows up to the call. Then I modelled the content so an agent could reason over it instead of searching it.

The dataset: 136 rules, 58 sources, 11 policy areas, 40 eval questions, 11 documented contradictions (C1 to C11). One rule is one claim Discord makes, quoted verbatim from one page, with the conditions under which it applies: appliesWhen (users, servers, intents, verification state, region, owner age), effectiveFrom and effectiveTo, a source reference with an authority score (because Discord staff said on GitHub that support articles reflect user functionality, not bots), supersedes, conflictsWith, resolution and confidence. Of the first 100 rules, 55 are confirmed and 45 inferred, and the agent has to say "inferred" out loud when it uses one.

Two Sanity Context endpoints, because an endpoint with a dataset source ignores its knowledge base sources:

bot-lawyer-rules is GROQ mode over the dataset, filtered to _type in ["rule","source","policyArea"] so the agent cannot read the eval questions. Tools: initial_context, schema_explorer, groq_query, array_field_reader. It answers anything that depends on a number or a state.

bot-lawyer-kb is knowledge base mode over 90 snapshotted Discord pages (docs, both help centers, legal pages, GitHub issues). Tools: initial_context, knowledge_base_read. It answers "what does the page around the quote say" and holds facts I never turned into rules. Every ruling reads both: the rules give the verdict and the dates, the knowledge base entry gives the page around it, and the answer marks that part with "From the page:" so you can see which is which. Under each answer there is a "Pages read" line with the entries and their source pages, next to the "Rules on file" cards.

The app merges both clients into one Vercel AI SDK tool set. Both initial_context payloads are inlined into the cached system prompt, and groq_query and knowledge_base_read are re described so the model routes by intent. The eval made 68 tool calls: 46 groq_query, 22 knowledge_base_read, zero schema_explorer or array_field_reader, because the inlined context already gave the schema.

The knowledge base took 3 builds and raised 8 issues. Build 2 raised 4: one real conflict Context found on its own (the Monetization Terms page says "Effective June 6, 2024" at the top and "As of June 4, 2024" for the Growth Tier lower down; two facts, not one, I resolved it as June 4 and it became an Instruction), and 3 merge suggestions I dismissed. Then I wrote a manual Instruction for the June 10 change, scoped to the application, gateway, verification, privileged intents and change log pages. Context replied that this rule contradicts facts in two other entries and offered to rebuild them. Yes please 🤝 Build 3 raised 4 conflicts and Context found C1 by itself: "Thresholds: 10,000 unique users" against "Portal Issues: 100 servers", 8 sources. I resolved three. The fourth I left pending on purpose: App Directory says a support server is required before enabling discovery, Monetization SKUs never mentions one. Two processes, not a contradiction, and the only resolution offered is binary. Final count on the dashboard: 5 resolved, 3 dismissed, 1 pending, 5 active Instructions (4 from resolutions, 1 manual). Insights recorded 65 conversations.

Quick sanity check I did on myself, because a bot that just searches the docs and reads them back is not worth anyone's time. Type "90 servers message content intent" into any search over Discord's pages and the top hit is the flags table: "100 or more servers". A real page, a real URL, a wrong answer, because that table was never updated in June. Bot Lawyer gets it right only because the old rule has effectiveTo set and the new one points at it with supersedes. Same with "retry_after seconds or milliseconds": search gives you both pages and a shrug. Here both rules carry conflictsWith, a written resolution, and each source has an authority score, so the answer is seconds and it can tell you why the support article lost. That is the whole point of putting this in Sanity instead of a vector database: the structure does the arguing.

What broke

The Studio deploy failed twice: studioHost missing, then @sanity/icons v5 has no named exports from the index, you import per icon. The best practices reference said exactly that. I did not read it closely enough.
The first knowledge base build was refused: "plan limit for indexed documents is reached (303 of 150 used)". My 177 page live crawl plus a ZIP of snapshots was double the cap. I deleted both and curated 80 files.
Build 1 ran 10 minutes and died with "The outline's structure stopped converging at thin_leaves (1 remaining) after 3 rounds". Build 2 resumed and passed.
Haiku skipped groq_query, answered the retry_after question from the knowledge base alone and said "both sources agree". They do not, that is C5. The prompt now mandates GROQ first and forbids "sources agree" unless the dataset shows no conflict. Haiku ignored the order anyway, so it runs on Sonnet.
My GROQ hint was wrong twice. area->slug == "rateLimits" returned nothing, because slug is an object and the seed used kebab case anyway. The ids are area.rateLimits.
The "case file" tool call lines never rendered. MCP tools arrive as dynamic-tool parts in the AI SDK stream, not tool-<name>.
The first design was black text on a black background. Very legal, very unreadable. I threw it out and rebuilt the whole UI as a Discord DM, because the audience lives in Discord and a memo embed with a green, red or yellow bar makes sense to them before they have read a word. The sidebar has a #billing-never channel. It is the only promise in this project I am fully confident about.
I burned a $7 test key in one afternoon of evals and took the public demo down with it 💀 Every call was carrying both initial contexts uncached, about 15,000 input tokens, a hundred times over. Now the system prompt is cached, every request is metered, spend is capped at $3 a day, and if the key dies the route falls back to Vercel AI Gateway.
Anonymous reads on the public dataset come back empty. I thought I had broken something, so I created a fresh public dataset with one document: same result, "permission", while Sanity's own public demo project answers anonymous queries fine and the security page for my project says "2 public datasets". So it is the project, not the data, probably the trial. The ledger page reads with a server side viewer token for now and the question is in the Sanity Discord.
Bot Lawyer, the app that tells you to turn off privileged intents you do not use, had all three privileged intent toggles on in the Developer Portal until my own test pass caught it 😂 Physician, heal thyself. It now runs with zero intents and mentions this in its own footer, which is the most passive aggressive thing I have shipped.

Eval

40 questions, written from the contradictions I had found, graded by a separate model against expected answers, spot checked by hand.

kind	PASS	PARTIAL	FAIL	items
trap	7	1	0	8
standard	22	6	1	29
unknown	2	1	0	3
all	31	8	1	40

Ruling right on 39 of 40. 0 of 8 traps fell for the stale 100 servers answer. 22 of 40 read the knowledge base, 12 surfaced a contradiction, 20.6 seconds average. The one FAIL was a real defect: a knowledge base summary sentence went into a blockquote attributed to a page that does not say it. I added a provenance rule (blockquotes only from a rule's quote field or the page's own words) and re ran the four answers that had that smell. All 12 blockquotes in the re run are verbatim in the page snapshots, checked by string match, not by eye. The table above is the original run; I am not going to re grade the whole thing to make the number prettier.

Honest limit: I wrote the questions and I built the dataset. This measures whether the agent reads the structure correctly, not whether the structure is complete or right. It is not a benchmark.

Cost: about 9 cents per question on Sonnet.

Sanity Project Details

Project ID v6745vem, dataset production (public). Studio: https://bot-lawyer.sanity.studio. Context endpoints bot-lawyer-rules (GROQ mode) and bot-lawyer-kb (knowledge base mode, 90 sources). Anonymous queries currently come back empty on this project even though the dataset is public (details under What broke); a read token or the Studio shows everything.

Agent Session

I built this in Claude Code and recorded the session. Being curated down to the bits worth watching: the icons fight, the thin_leaves build, the Haiku "sources agree" moment, and the afternoon I set fire to a $7 API key. Public before this post goes live.

Two things in here I did not invent: the two endpoint setup with merged tools and the initial context inlined into the prompt is from the Sanity Labs agent workshop, and every word of content is Discord's own docs, support articles, policies and change log. The opinions about which page is lying are mine.

The thing I still cannot solve: Context's pending issue wants me to pick a winner between two entries that are both right, which is also how most of my community disputes end. Is there a way to tell Context "not a conflict, keep both" that I missed, and if not, how are you handling it? 🔥

And if you run a Discord server and your channel names are still general and general-2, you know where to find counsel.

sanitychallenge #devchallenge #buildinpublic #discord