Executive Orders. In Plain Language.

A couple of weeks ago, the backburner project that had gotten half of my attention while life (and a whiskey collection) got in the way sat in a CLI tab. I was both a little embarrassed and mildly frightened of what state it might be in. Today it's live, and the speed-to-delivery isn't really the important part, though, really, the delivery time doubled since I first wrote this article because I almost thought good enough was good enough.

The build story was boringly short at first, and then I did that thing where I become really invested in an outcome and I realize that the solution that looks easy enough, or might be good enough in someone else's hands has now landed in mine. And I sometimes lose the battle of good enough versus perfect, so here we are.

Generative AI can be embarrassingly easy, and the AI hype crowd is doing their darnedest to race us right to the most mediocre possible outcomes with their scrape-and-regurgitate-automate that never sees the light of human eyes. Generative AI with a bunch of levers in place to drive the potential for embarrassment down a few notches, well, that takes some effort, and some time.

I've been actively building, and still actively improving, a side project that I believe, and sincerely hope, does some public good. Executive Order Translator eotranslator.com ingests every new U.S. Executive Order and translates it into plain language: what it requires, who's on the hook, and why a normal person might care. I even added in a bit of a compliance matrix-like table that can be downloaded as a CSV in case that helps someone along the way.

Why Executive Orders?

Executive orders move real policy in the United States. They can change how agencies spend money, who gets hired, and what gets enforced. And they're published in a format almost nobody reads: Federal Register prose, dense with statutory cross-references, wrapped in boilerplate. And oh my gosh, they're just boring and dry and can be exhausting to get through.

And because of that previous sentence, a lot of people learn what an order means or does from a news headline or someone else's sort of informed hot take. The distance between "what the government ordered" and "what people believe it ordered" is where a lot of our civic noise lives.

Plain language can close some of that distance. I've felt that for a long time; it's the same conviction that ran through my years working in the Federal government. Clear writing about government activity is a public service. And the problem with all of this is that it's not exactly simple to write plain language around a lot of government-speak, no matter who is in office.

Another part of the distance between meaning and belief is a lot newer. AI can summarize anything now (the hype crowd, again), instantly and cheaply (and when you one-shot your way through summaries, it's definitely cheap, if not cheap and dirty), which means a summary by itself is worth almost nothing. You have no way of knowing whether the summary is faithful to the source, unless you're putting in the time to validate claims, force reference citations, and check the work.

And you have to check that work yourself, if you're attaching it to your name in any way, shape, or form.

So the summary is table stakes, for certain. Anyone with a prompt box and a token pass can generate one.

The feature, well, that is that increasingly important receipt.

Check the Receipt

Every claim on EO Translator has a reference number, and that's one of the first receipts you see as a user. When you click it, you're shown the exact sentence from the executive order, and you can jump to that sentence highlighted in context inside the full official text, right on the page.

And, not for nothing, that's generally what my version of table stakes starts with. I need you to at least have the opportunity to see that I'm not just full of prompt and circumstance hype when you see something I've worked on.

That's the part you see. Here's the invisible machinery part that you don't:

• The plain language is written blind. The model that drafts the summary never sees the raw executive order. It works only from a structured distillation of the facts, who has to act, what they have to do, and whether it's required or merely allowed, with the original legal wording physically withheld from it. That way, it can't paraphrase its way into trouble because it never has the words to paraphrase in the first place.
• Every numbered obligation traces back, by construction, to a specific quoted span in the order. That is the receipt you can click on to check. The one-line summary and the "why it matters" note are built from the order's stated purpose and those same facts, so they answer to the meaning check below rather than a per-sentence quote.
• A deterministic check confirms every quote exists in the source, character for character. This is software string-matching, and there's no AI involved, and not one model grading another model's homework. This is much better math than I can do on my own.
• A meaning check reads the plain language against the order on six points: who has to act, whether the action is required or only allowed, how far the rule reaches, whether the work is finished, proposed, or still under review, whether a legal limit or condition got quietly dropped (the "subject to the availability of appropriations" kind of caveat that changes everything), and whether the summary slipped in any characterization the order itself never made.
• The model flags anything that reads differently, and the flag is a lead, not a verdict. The editor (and that's me, the owner of all the flaws and mistakes in all of this) makes the call.
• Anything incomplete announces itself. If an obligation didn't survive the pipeline, the draft wears a banner saying so. Nothing gets to look finished when it isn't. (This rule has a body count; more on that below.)
• Then I review it (because I am, again, the editor). Every claim, against the order, rewriting as much as it takes. And when I edit, my rewording goes through the same meaning check the machine's did. Nobody skips the line, including me.
• If the Federal Register amends an order's text, the summary gets pulled automatically until a human (it's still me, I'm still the human despite an over-subscribed supplement regimen) re-reviews it against the new version.

I wanted trust to be a simple interaction: a mouse click or a thumb tap that exposes the proof immediately, instead of a badge you're asked to believe. Making that happen meant we had to create a lot of hoops on the backend, then I doused them in kerosene, lit them on fire, and proceeded to attempt to jump through them.

By Now, We're All a Little Fatigued By "How I AI'd This Thing"

I thought I was going to be brief. It's new for me and a real struggle, and I sincerely had your best interests in mind. And then I started checking my receipts and realized I needed to tell you how I AI'd this thing.

The division of labor followed the framework I wrote about in "Apps at the Speed of Need": I made the judgment calls, Claude turned them into plans committed to the repo, Claude Code built from those plans, and Qwen generated content mapped to the guardrails we provided while I kept my hands on the gates. Nothing published without my approval, nothing got approved without evidence on the screen, and there was more content and prompt editing than you care to hear about.

There is a small sidebar here that's possibly uninteresting, however, it is truth in lending, and also just the way I work: I don't blindly direct Claude Code to "go do this prompt, robot" and that's very intentional. Given the harness I've built, and given that Claude Code knows the infrastructure and can see things that I have partly walled off from the Claude desktop app (this is just a preference), I've set this up as a 3-way collaboration to ensure we're thinking as big and broadly as we can without over-directing on how to develop and deliver within the infrastructure. It adds extra steps as we work through challenges and refinements together, and the differences in when either of them compact (run out of memory and summarize themselves) allow me to personally hold more in memory and check the plan just a little easier. This feels like I'm probably doing something wrong, or missing some efficiency that someone else has solved, however, it works for me!

One of my favorite (though not so awesome at the time) early moments was a failure. The verifier flagged 8 of 31 summaries as ungrounded, and for an hour I thought the model had been inventing quotes, which meant I had to read, in detail, more executive orders than I really wanted to. My investigation showed the opposite: the Federal Register's own formatting, page markers and line-wrap hyphens, was breaking the matches. The pipeline was more verbatim than its source and the only way to learn things like that is when the system is built to check itself.

Also for the record: the first version of the front end earned an F+ from me, largely because it matched my sketched wireframes. I slowed my own process to invest time in branding and sensible design elements, not allowing myself to get lazy and bring you an AI purple or beige monstrosity that looks like all the others. It's a green monstrosity that looks like all the others, however, it's mine.

Taste still has a job, and I'm Rick Rubin-ing my butt off over here.

And I'm telling you about this failure and the F+ because they were, in hindsight, the fun ones. The first one taught me the system could catch its own mistakes, and the second one taught me I still had a design job. What I didn't know yet was that the next three weeks would be a parade of quieter failures. Those were the kind that don't flag anything, don't look like anything, and sit there politely looking finished. Until I was in the role of editor, editing, and then finding one of those mistakes that makes you wonder if you're being gaslit. Then we fixed it, reprocessed 30 executive orders, and I started editing again so I could identify the next one.

Finding those, and the right way to fix those is what took the most time. While I was in pursuit of those receipts, I ended up finding out that all those failures turned out to be the same failure on repeat.

The System Knew. It Had No Voice.

The three weeks after launch were spent discovering, repeatedly, that the difference between a demo and a trustworthy tool is a long list of things nobody claps for.

I was in an editorial moment of frustration when that gaslit feeling hit, and I'm sure I loudly asked (typed) whether the model (Qwen) writing our plain language was ever seeing the executive order it was translating.

The answer turned out to be no.

The pipeline that fed it meaning, performed the checking, and passed the judgments had never been connected to the source of its own truth. Everything had been working beautifully in a test harness with a limited blast radius (see also: what looks good for a test of one may not scale to a test of many). There was a function with "testbed" literally in the name, and the production system had been routing around it the entire time.

And the best (worst, it was the worst) part: buried in the data was a flag that blatantly said as much. The system had recorded its own failure, accurately, into a field that nothing on earth ever displayed.

It knew. It just had no voice.

That became the theme of the next two weeks. A Regenerate button was on mute when it destroyed an evening of my editing because nothing warned me it would.

A choice log faithfully recorded every correction I made while nothing, anywhere, ever read it.

I had been told the system was learning from my edits, and there were plenty of times where I felt I was repeating the same substitutions across multiple executive orders, so I spoke up. And I learned that the system wasn't really learning so much as it was keeping a diary.

There is a difference between capture and learning, and I found it the hard way, at about forty frustrating edits deep.

We gave EO Translator a voice. I was getting tired of talking to myself, so I made sure that the button now tells me exactly what it's about to destroy and archives everything first. A defective draft announces itself with a banner instead of rendering politely and embarrassingly landing on a web page (though I'm sure some of my late night edits may eventually embarrass me).

And my corrections finally got wired into the drafter as teaching examples (distilled by my own hand and not some magic feedback loop), and I know it took because we tested it on obligations it had never seen: the exact governance details it used to drop on every single order, the "who must consult with whom, through whom" chains that plain language loves to erase, now survive without me. Grading that test is the closest I have felt to being a proud parent of a very large matrix of numbers. Wow, I really just wrote that. Dork.

Then I turned on the scoring and found out our readability rubric was, and I say this with love and a quote from Colonel Sherman Potter, "horse puckey." We asked the model to judge our content with seven questions that our persona would answer, and when we finally tested them against my own edited corpus, five of them were dead weight.

One question asked if the writing "avoids bureaucratic phrasing" and answered no to everything, including the plainest sentence in the corpus, because the sentence contained the Secretary of the Treasury, who is, to be fair, a bureaucrat.

The fix produced my favorite finding of the project: questions shaped like "Could a busy adult with no legal training explain this to a coworker coherently after reading it once?" measure something, and questions shaped like "does this text have good property X" get a cheerful yes for everything, including a 79-word run-on.

It's kind of wild; when you ask the machine to simulate a person it gets painfully honest, and when you ask it to grade an essay, it grades on a curve. Well, thanks, machine, now I am better at knowing how to grade you.

Every one of those bugs was the same bug wearing a different costume: something failing quietly and looking finished. Every fix was the same fix: give the failure a voice.

It's not like I wasn't planning for error states, or I was ignoring steps in a process. Validations and checks were in place; the voice just wasn't in the right place with them.

No, Really. Check the Receipts.

One more thing happened while I was down in the engine room (my office) being gaslit by my own pipeline: readers started showing up. I'd quietly launched the frontend for testing purposes and had made no announcement nor published an article like this. This was just Google quietly indexing pages full of the Federal Register's own vocabulary.

To my surprise, those readers skipped the flashy quantum computing executive order almost entirely. The handful of readers who found the site jumped into executive orders that were more focused on federal contracting, land access, and the financial system.

It turns out the people who go looking for an executive order in plain language are, disproportionately, the people the order obligates, and what they need is exactly the unglamorous stuff I'd been grinding on: the qualifiers kept, the consultation chains intact, and the "must" that stayed a "must consider." (Believe me: I know this is speculative with incredibly limited data, so enjoy the outlandish leap I'm making, however, at least give me credit for acknowledging it!)

All that fidelity work I occasionally (frequently) resented was always the end product.

Over 30 executive orders are live, browsable by topic, searchable, and syndicated by RSS. The next time a headline tells you what an order says, you've got a place to check: eotranslator.com.