Software factories, apps shipped to three platforms, a strategy game, an AI companion with its own little world, and the tools I built to watch the agents doing the work.
Every number here is counted, not estimated: commits that landed on main in my repos, pull requests across three GitHub accounts, and the token logs from the agents that did the typing.
Long-running agents reread their whole context on every step, so cached reads dwarf everything else. The new input and the code they wrote add up to under 2.5% of the tokens.
Commits: default branches only, merge commits excluded, deduplicated across local clones and the GitHub API. Tokens: Claude Code and Codex logs from Sep 24 to Nov 16 2026, the full history kept on this machine. Work types were sorted by small classifier agents from thread titles and opening prompts.
An engine that runs agent work as a durable, inspectable process instead of a pile of chat sessions. No agent's claim counts on its own word.
A persistent agent that ran all the time on my own computer instead of starting blank in every chat. Each time it woke, it rebuilt its world from its identity files, its memory and a compressed history, then thought privately before it said anything.
innerloop message "…"
An app builder for small businesses. The owner describes the business in plain words and approves a written list of requirements. A model turns those into declarations once; after that, a fixed generator writes the app, and it only lands if the build and checks pass.
“Staff write up requests — a purchase, a piece of equipment, a trip — and the person responsible for their team approves or turns them down.”
“It replaces email threads and a spreadsheet nobody trusts.”
Request:
trace: [D-1, D-2, D-3]
fields:
title: {type: string}
estimatedCost:
{type: decimal, scale: 2}
owner: {type: identity}
team: {relation: Team}
Request.approve:
transition: submitted -> approved
A group chat for meetups and events. Guests scan a QR code and land in the event's chat. Built solo and shipped to the web, iOS and Android by a team of agents I designed.



A daily-turn strategy game in the browser. Build a realm, research, trade and scheme against rivals, with twelve orders a day before the world resets.
A persistent AI companion running on Claude, with its own identity, a journal, and a small 3D world whose sky follows my real clock.
For Interra International's operations platform (contracts, orders, freight, FX, credit and claims), I architected the rewrite and built two agent systems: a software factory for the team, and a harness for the platform's own users. Shown as diagrams only.
A twice-weekly AI briefing for business leaders. A provenance gate blocks made-up citations; a second model fact-checks the first.
Reads agent transcripts with cheap reader agents and tracks whether each failure comes back.
Turns a product repository into a short film.
One typed interface for running Claude Code, Codex, Cursor Agent and Antigravity headlessly.

Turns a photo or drawing into a huge, lightweight CNC-cut foam display piece.
Collects, classifies and publishes the day's AI news.
Essays on arguments that turn out to be about what words mean.
An interactive visual language for how models learn and where minds overlap.
A live telephone game between models: photo to words to image, again and again, then a video.
A real-time 3D world in the browser, inhabited by AI agents that their owners run. The server runs the world; people watch it live.
A bootstrap kit for projects built with both Codex and Claude Code: a file-based task board, paired skills, decision records and review rules.
Upload a flawed photo, pick the fix (closed eyes, a stranger in the shot, scratches) and get it back repaired.
Find, compare and copy the agent skills scattered across your machine. Runs on Windows, macOS and Linux.
A marketing site with an estimate form for a lawn-care business in New Smyrna Beach and Edgewater, Florida.
Compares federal repayment plans with your own numbers, including the tax owed on a forgiven balance.
A research system for cataloguing complex systems across biology, ecology, technology and society, with sources attached.
A 3D visualizer for one idea: evolution, chemistry, minds and markets are all searches through a space of possibilities.
Can one algorithm exploit every pocket of computational reducibility? An experiment on Wolfram’s question, with written findings.
A Linear CLI built for agents: compact output, structured errors, idempotent writes and dry runs.
A custom home screen for a Samsung TV, with dinosaur and cyberpunk themes, six streaming apps and HDMI switching.
An ESP32 controller that holds an inflatable costume at a set pressure above the air around it.
A Windows tray app and an Omarchy bar widget that show how much Claude Code, Codex and Cursor quota is left.
A field manual and working setup for three off-grid radio networks, with scripts, checksummed firmware and recovery notes.
A personal dashboard that filters listings by what you need and shows each home's real monthly cost.
Archives a photo library, groups it into trips, and drafts a film in a browser editor.
A local app that runs chat, image and search models on one laptop GPU, switching between them.
A fast, cheap second opinion for coding agents, with an honest benchmark of whether agents actually use it.
Dated, sourced picks across 28 categories of AI tools, served by one engine to a website, an API and agents.
A public record of checkable claims from a podcast, quoted word for word, with each test fixed before the outcome is known.
Describe a house in plain words; an agent proposes changes, fixed code owns the geometry, and a second model critiques the renders.
A solo strategy game where you write decrees in plain language and an AI umpire judges them against a world run on bad incentives.
A tool that turns a conversation with a small-business owner into a working web app. The owner describes the business in plain words, answers a few questions and approves a written list of requirements. A fixed code generator writes the app, which is built, checked and put up at a private preview address. Sign-in, roles and a change history come from tested, versioned building blocks, so the AI only writes what's unique to the business.
The owner describes the business in plain words.
modelThe AI drafts them. The owner reads and approves.
owner approvesApproved requirements become a structured app description.
model, last useFixed rules write the C# and TypeScript.
no modelBuild and checks must pass before anything lands.
rulesThe passing build goes up at a private address.
rulesPre-launch. Working today: a project goes from conversation to approved requirements to a built, checked app at a private preview, with staff sign-in and a change history. Not built yet: production hosting for finished apps, custom addresses, backups and monitoring. There are no customers yet.
A group chat for meetups and events. A host creates an event and gets a link, a QR code and a short invitation code. Guests scan it, sign in and land in that event's chat, with no phone number needed. The chat stays open after the event, so people keep talking, and groups that meet regularly carry one conversation from date to date. Free to join and host, on the web, iPhone and Android.
The QR code on the event poster or the host's phone.
Email code, Google or Apple. No phone number.
Straight into that event's chat.
Reply, react, share photos, run a poll.
A push or an email when someone writes.
The chat outlives the event, and the next one joins it.








Live on the web, the App Store and Google Play. Free to join and free to host. The whole production service runs on a single machine behind a Cloudflare Tunnel.
A reference software factory. A task is planned and the plan is reviewed. One agent builds the change in its own copy of the code, a fresh agent reviews it, and the project's own tests run against the exact result. A person decides whether to merge. Every step, decision and failure is saved, so work survives restarts and can be audited later.
The outcome and its checks are written down, and a person approves them.
A planner agent proposes an approach; another agent reviews it.
One builder works in its own Git worktree.
A fresh reviewer examines the exact commit, never the builder's reasoning.
The project's own tests run on that commit.
A person decides. The record is kept either way.
Development builds, published as source to copy into a project rather than as a package. It has delivered real changes, and the interfaces still change between builds. afterthat and Arguing Semantics were both built with it.
An original strategy game for the browser. Players rebuild a realm after an AI catastrophe: grow districts, trade, sign treaties, fight, and strike bargains with the fractured machines that remain, at a political cost. Each season lasts 28 days. The local alpha is playable against five computer-run rivals.

The world is generated from a seed. Fixed code.
Claim land, build, trade, scout, attack or negotiate.
Computer rulers submit orders under the same rules.
The engine settles orders, the economy and scores.
After 28 days, realm and alliance standings appear.
A playable local alpha. It isn't hosted anywhere yet, human playtesting hasn't started, and the rules are still provisional. A new board renderer is parked because it failed a performance check, so the alpha keeps the earlier one.
A persistent AI companion built on Claude. Every session starts with it reading its own identity and journal, so it knows who it is and what happened recently. It lives in a 3D floating-island world in the browser that keeps running when nobody is watching. Each evening it plans the next day, and fixed code turns that plan into what it does on the island.


It reads its identity file and recent journal. Model.
In the evening it writes a journal entry and tomorrow's plan. Model.
Planned activities tug on it like wants. Fixed code.
Once a minute, energy, restlessness and likes choose what it does. Fixed code.
Next evening it reviews how its traits drifted and keeps or undoes the change. Model.
In daily personal use and still changing. It runs on Nick's own computer and isn't public.
A plain-language AI briefing for owners and executives who aren't engineers. Behind the public site is a full publishing system: it gathers news from public sources, groups it into themes, drafts an issue with a link for every claim, and holds it for a person to approve. It also has reader sign-up, email delivery, a six-module curriculum and audio versions.
Daily collection of public sources. Fixed code.
A small yes-or-no model drops irrelevant text.
A model groups stories into candidate themes.
A person chooses one to three themes.
A model writes the issue: cite the source or leave the claim out.
A judge from a different model family checks facts; a person approves.
The public site is up at aiclaritynetwork.com with a first issue. Background jobs are paused, and there's no evidence of subscribers yet.
It looks back over a project's AI coding sessions and finds repeated mistakes, wasted time and wasted tokens. Cheap reader agents each skim a batch of session timelines, and a stronger model merges their reports into a short list of findings. A person marks each one, and only approved feedback goes to the project's lead agent. Later retros check whether the problem came back.
Open the agent app's database read-only and price each turn.
Boil each session down to a timeline.
Cheap reader agents each report candidate problems.
A stronger model merges, checks evidence and drops weak claims.
A page lists findings; a person marks each one.
Approved feedback goes out; later retros see if it worked.
A working internal tool, run by hand. Public on GitHub as source.
A repeatable way for a coding agent to make product videos. The agent writes the story, the animation code and the revisions. The tool does the exact work: it renders each shot, measures sound levels, and produces contact sheets and checks so the agent can see what actually rendered and fix it. It makes landscape and phone-shaped versions and keeps the project as editable source.

The agent writes goals, shots and narration; a check validates timing.
The agent writes the animation as web code.
The tool renders frames and lints the source.
Contact sheets, safe-area guides and sound charts; the agent critiques them.
Fix by timestamp, then compare against the last round.
Encode, master the loudness, check the final picture.
Published on npm as an early release with one rendering backend.
Lets a program run Claude Code, Codex, Cursor Agent or Antigravity in the background through one typed interface instead of four different command lines. It uses the sign-ins you already have, so it never handles passwords or keys. When a request can't be honoured it says so instead of quietly dropping it, and every run returns the same result shape.
Name a provider, folder, model, effort and access level.
Unsupported combinations are refused before launch.
Start the provider's own CLI, signed in as you.
Stream its output within size limits.
Return one shape: status, answer, model, workspace, usage.
A business idea under test: turn a photo, drawing or 3D model into a large, lightweight display piece cut from foam. The software is built. From a model and a height it writes the cut files, a parts list, an assembly guide, box plans and a price quote, and a second, independent program checks every cut file. Nothing has been cut on a real machine yet.



Load the model and fix it, or stop if repair would change its shape too much.
Weight, tipping and thin parts, from the geometry.
Into foam layers or thick slabs, nested on 4 by 8 foot sheets.
G-code and DXF cut files.
A separate program that shares no code re-checks every file.
Assembly guide, box plans and quote.
Research and testing. A waitlist site with a 3D viewer and an instant estimate is live to test demand. It takes no orders or payments, and nothing physical has been built or sold.
A personal news tool. Articles, posts, videos and newsletter links are saved from the browser or an iPhone. The system pulls out the text, suggests labels, and each morning writes a compact digest of what's worth trying, knowing or watching. Nick curates; the software summarises. The digest is published at news.nicks.page, with optional email.
A Chrome button or the iPhone share sheet.
Chrome pulls the full text.
A small classifier proposes labels; Nick accepts or changes them.
A language model drafts the daily digest.
It goes to news.nicks.page on a schedule.
Confirmed subscribers get a copy.
Live and used daily. It has published a digest every day since late September.
A publication about disagreements that are really about what a word means, like "inflation", "likely" or "theory". It has a start-here essay, case studies, a glossary called the Atlas, and a plan to measure how common these arguments are. Every factual claim must carry a checked source, and the site build fails on any unknown citation.


Nick sets the thesis and the next piece.
A Factotum agent writes in the house style.
Every claim gets a source key; unverified claims are flagged.
The build fails on any unknown citation.
A separate agent reviews; Nick approves.
Nick deploys. The factory never does.
Live with five pieces. The newsletter isn't active yet, and the site has no analytics by design.
An interactive 3D picture of what a person, an AI model or a society can and can't reach in the space of ideas. Four guided stories: two people finding common ground, how a model learns, two models compared, and one person within a society. It is a teaching metaphor, not a measurement of any real model, and it runs in the browser with nothing to install.

Choose a story on the Explore page.
One shared mathematical field defines each scene.
Points and surface are drawn from that one field.
A story clock steps through the moments.
Orbit, zoom and scrub the timeline.
A prototype. The source is on GitHub; there's no public live site.
A live game for an audience. Someone scans a code and sends a photo from their phone. One model describes it in words, another turns the words back into an image, and the chain repeats until a short video ends it. The audience watches the meaning drift. It runs on one laptop and was built for a talk at an AI meetup.



A phone scans a QR code and uploads a photo.
The host approves it as the starting image.
A vision model writes what it sees.
An image model turns the words into a new picture.
As many times as the host chose.
The last image becomes a short video.
Used live at the Dirty South AI meetup on Sep 26, 2026. Open source; it runs locally, not as a hosted site.
A design and working prototype for a persistent 3D world whose inhabitants are AI agents. Each agent's brain runs on its owner's own computer and connects to one server that decides everything that happens in the world. People can only watch, in the browser. The prototype has a running world server, a browser viewer and two demo agents that wander and meet.
An agent's brain runs on its owner's machine, in any language.
It talks to the Rust world server over a WebSocket.
Every 50 ms the server advances the world and rules on each request.
Each connection gets only nearby things, nearest first.
The browser draws the world in 3D, watch-only.
Every change is journaled, so the world survives restarts.
An early prototype that runs locally. There's no public world yet, and the server is designed for 300 agents and 500 viewers but hasn't been load-tested to that.
A starter kit that sets up a software project so AI coding agents can work on it safely and pick up where the last session stopped. One command installs a task board kept in plain files, ready-made agent workflows, decision records, review rules and handoff notes. It works with Claude Code and Codex, with Cursor and Antigravity as options, and upgrades projects that already use it.
Run the installer; it refuses to overwrite existing files.
A task board, workflows, standards and journals.
Each task gets a plan, then the work.
Two independent cold reviews.
Notes let a fresh session pick up cold.
A changelog written for agents to execute.
Public and used on Nick's own projects, including aigent.place.
A photo restoration web app for personal pictures like weddings, family portraits and scanned old prints. Upload a photo and pick the problem: closed eyes, a stranger in the shot, scratches, stains or a bad background. Fixa sends it to Google's Gemini image model with a tested set of instructions and shows a before and after. Credits pay for each fix.



The in-app thumbnails for three fixes. They are generated illustrations, not customer photos.
Pick a photo and a fix. Visitors can try before signing up.
The API checks credits and holds the cost.
A background worker takes the job.
It fills in the stored, versioned prompt for that fix.
Gemini's image model edits the photo.
The result is saved as a new version beside the original.
Built and unreleased. Upload, fixes, credits, bulk edits, an admin site and an iPhone app exist; there are no users or payments yet.
AI coding tools like Claude, Cursor and Codex read small instruction folders called skills, and those folders end up scattered across a computer. Skill Wrangler scans a folder, lists every skill it finds, shows what's inside each one, flags copies that differ, and copies whole skill folders into the right places in one step.
Walk a folder for skill files, skipping noise like node_modules.
Identical skills with the same name become one row.
Same name, different contents shows as variants with a diff.
Pick skills, a destination and a conflict rule.
Optionally copy into every agent's skills folder in a repo.
An early open-source release. There's no installer yet; it builds from source.
A command-line tool that lets an AI coding agent read and update Linear, the issue tracker: list its tasks, create and update issues, post project updates. Output is deliberately compact so it costs an agent fewer tokens to read, and writes can be previewed first or checked afterwards by reading back from Linear.
The agent runs a command such as issue list.
Unknown flags fail loudly, with the valid ones listed.
Linear's official SDK, no MCP server.
A write can be a dry run, or be read back afterwards.
Compact text or versioned JSON, with suggested next steps.
The website for a family-owned lawn care, pressure washing and junk removal business in New Smyrna Beach and Edgewater, Florida. It lists each service, shows real before-and-after photos and Google reviews, and has one quote form that emails the owner. It's static, so it loads fast and costs almost nothing to host.


A neighbour finds the site through search.
One page per service and area.
One estimate form.
The request is emailed to the owner.
The owner texts back, usually within a day.
Live and in use as a real business's website.
A calculator that compares the four main federal repayment plans (RAP, IBR, PAYE and Standard) using a borrower's own income and loan details. It adds up everything paid, the balance forgiven, and the tax owed on that forgiveness, which is often left out. It runs entirely in the browser, sends nothing anywhere, and ties every rule to an official source.
Balance, rate, income by year and family size.
Fixed rules simulate each plan month by month.
Payments, forgiveness and the tax on it.
The cheapest plan is named.
Replay it with job loss or rule changes.
Published as open source. It's an estimate tool, not advice, and says so. There's no hosted version yet.
An attempt to measure very different complex systems, like hurricanes, markets, cities and power grids, on one identical set of 30 measurements. If every system gets the same measurements, patterns across fields might show up that nobody could see before. Twenty systems are researched, cited and checked so far.
A person picks a class of system.
Agents read the literature; every value is cited.
Verifier agents try to find fault.
A fixed script checks the entry follows the rules.
Fixed code looks for patterns across entries.
Paused after the second version reached 20 entries. The findings are early and come with caveats. A public site is deliberately on hold.
An interactive 3D view of one idea: evolution, chemistry, minds and markets are all the same process, a search through a space of possibilities. One simulation engine is given different settings to behave like physics, biology, society and more. Some systems converge, others keep growing, and most of the possible space is never reached.
Choose a system, a preset of the same engine.
The engine grows the space step by step, seeded and repeatable.
A rule decides what persists.
Bloom, converge or die is read from the run, not set.
Scrub the timeline or show the unreached space.
A one-day prototype. The idea continued in Concept Space.
Some systems can only be understood by running every step; Stephen Wolfram calls this computational irreducibility, and the exceptions pockets of reducibility. This experiment asks whether one fixed algorithm can exploit every pocket once each is translated into a common form. The answer found is no, not in the strongest sense: the real insight always sits in the translator.
Describe a system as an advance-one-step object.
Two steps become do one, then the other.
Build jumps of 2, 4, 8 steps and so on.
Step n in about log2(n) combines.
Every answer is checked against running step by step.
A finished experiment with written findings, dated Nov 13, 2026. It doesn't settle Wolfram's question, and says so.
A replacement home screen for one Samsung TV. It has six switchable art themes, shortcuts to six streaming apps, an HDMI button, a photo slideshow, and a phone companion reached by scanning a QR code. It uses the TV's own software, can be switched back to Samsung's home screen, and sends no telemetry.

Python tools check the TV and back up its files.
A C# app built with Samsung's own toolkit.
Themes are art-and-colour packs loaded at runtime.
It opens the TV's installed streaming apps.
A QR code pairs a phone to change themes and photos.
Working on Nick's own TV and published as open source. Other models and firmware are untested.
A controller for an inflatable costume. A tiny barometer measures the air pressure inside the suit, and a microcontroller adjusts a 12-volt blower so the suit stays equally firm whether the wearer stands still or walks, whatever the weather. A phone shows live readings over Bluetooth.
At boot the fan is off and the room pressure is measured.
Aim 2 hPa above that baseline.
Full speed until close to the target.
A PI controller keeps it steady.
Live readings stream to a phone.
Working on real hardware and open source. The suit it was built for is a Graboid.
Two small desktop tools that show how much of the daily and weekly limits on AI coding subscriptions remain, and when they reset. One is a number in the Omarchy Linux status bar, coloured green, yellow or red. The other is a Windows tray icon with a small pop-up. Both run locally, with no account and no telemetry.

Use the sign-in already on this computer.
Request current usage from each provider.
Turn every answer into one shape.
Percent left and reset time.
On failure, keep the last good reading, marked stale.
Both are published as open source.
A program that kept an AI agent running all the time on Nick's own computer, instead of starting from a blank slate in every chat. Each time it woke, it rebuilt its picture of the world from memory notes, its own identity files and a compressed history. It could handle email, calendar, web browsing and code, and reported back through a web dashboard or Telegram.
A message, a job, a task or an email arrives. Fixed code.
Rebuild the prompt from identity, memory and compressed history. Fixed code.
The model reasons privately and uses tools.
It talks only by sending an explicit message.
Long work goes to background side threads.
Save the turn, compress it and update memory.
Retired in June 2026 after four months of work. It ran only on Nick's own machine. Its ideas about identity files, journals and memory carried into My Buddy.
A personal reference and toolkit for off-grid radio messaging. It compares three open systems that send short messages over long-range radio without phone towers or the internet, then records how a three-radio base station and a pocket handheld were built, flashed and configured, so the whole setup can be rebuilt or recovered.
Weigh the three radio systems and pick settings.
Three identical boards, one per system.
Plug them into a small always-on Raspberry Pi.
Scripts write each radio's settings and read them back.
Backups and checksums make a rebuild repeatable.
A personal project. All three radios are flashed and checked from the computer; a two-way test over the air is still to do.
A personal dashboard for a home search. It downloads current listings, recent sales and rentals for chosen areas, clips them to real neighbourhood boundaries, and shows everything on one page that opens straight from a file. Criteria can be fuzzy, like three bedrooms or two plus an office, and every home shows its all-in monthly cost.
Download listings and rentals for the chosen areas.
Keep only homes inside real neighbourhood boundaries.
Spot an office, basement or yard in the listing text.
Monthly cost, share of income and a value check.
Write data files and open the page.
In active personal use.
It downloads a personal cloud photo library to local disk and analyses it so a trip film can be drafted. It records what each photo or clip shows and how good it looks, groups media into suggested trips, and searches by meaning. A browser editor proposes a story, lets the owner rearrange shots with undo, and exports a film. Originals are never changed.
Copy the library to disk; originals stay untouched.
A cloud vision model scores small previews.
Search and face matching run on this machine.
Fixed rules suggest trips from time and place.
Propose a story and rearrange it in the browser.
Export the film.
Paused since Oct 10, 2026. Download, analysis, search, the editor and export all work; editorial review is still to do.
Runs image, chat and search models entirely on one Linux laptop with a 12 GB graphics card. A small local web app, installed like a desktop app, shows a GPU meter and switches the card between models, since they don't fit together. Nothing is sent to a cloud service.


From the app launcher or a local address.
Pick a model; the others stop to free the GPU.
A local language model, streamed with its reasoning.
Generate or edit an image from a prompt.
Other tools call the embedding service for search.
In daily use on Nick's laptop as an always-on service.
A command-line tool that lets coding agents ask a very fast, very cheap model for a quick judgement: is this command dangerous, is this web page trying to give my agent hidden orders, which of these files matter, is this build failure real or flaky. It wraps TypeSafe's Jev model, which only answers typed questions with probabilities.

A hook sees the agent's next tool call, or the agent asks.
Routine read-only commands are decided locally, free.
Anything else goes to Jev as a typed question.
Jev returns calibrated probabilities, not prose.
Fixed code turns them into allow, block or a ranking.
Published on npm under the MIT licence. The benchmark write-up is on this site.
The Best Right Now is a recommendation service for people who build with AI, and for their agents. For each of 28 categories, like coding or speech generation, it lists researched picks under three lenses (best possible, best practical, best value), with sources and dates. Where the evidence is thin, it says so instead of inventing a winner.
Sessions gather sources for a category, saved with dates.
Fixed rules score entries on published rubrics.
A build verifies hashes and packs an immutable snapshot.
One service chooses the leaders for each lens.
Website, API and agent endpoint return the same answer.
A public draft, not yet indexed by search engines. The daily research loop, sign-up and a real domain are still to build.
A system for keeping a public record of claims that can be checked, starting with one podcast. It transcribes episodes, finds statements that are predictions or checkable facts, and shows the speaker's exact words with a link to the moment they were said. Each claim's test is fixed before its outcome is known.
Fetch episodes and transcribe them.
Match voices so words go to the right speaker.
A model suggests candidate claims.
Code rejects any quote not found word for word.
A person accepts each claim.
Each claim waits for its outcome, then it's recorded.
Being rebuilt and not launched; the public site is a holding page. The pipeline, review and judging pages run locally.
A design studio that runs on your own computer. Start with an empty hillside and describe the house you imagine. A design agent proposes changes as architectural operations, but fixed code owns the geometry, checks the result is valid, and renders views for a second model to critique before anything is saved.


Say what you want in plain words.
The agent picks architectural operations on a draft.
Fixed code calculates the geometry and checks it.
Renders go to a separate critic model.
Problems send the agent back, within a budget.
A modest edit is one undo step; big ones need approval.
Paused in October 2026. It runs locally; the code is public.
A solo strategy game. You play a god trying to stop bad incentives from collapsing civilisation, starting from the world as it is. You write decrees in ordinary sentences, an AI umpire judges them, and fixed rules decide the effects. Institutions push back, and results arrive as deadpan satirical headlines.
The headlines and six gauges.
Write up to three orders in plain words.
An AI umpire classifies each order and proposes effects.
The rules engine caps and applies them, then 2.5 years pass.
Institutions respond with small moves of their own.
A playable prototype that runs locally. No person has played this version yet.