A thought can be a URL now

I turned a Discord argument about biological wheels into a deployed website in a little over ten minutes on 4 July 2026.

The point is not that the simulation settled the biology. It did not. The useful change is that the thought did not have to stay as a chat message, or become a polished project, or wait until I had a proper reason to build something.

It became a URL: biological-wheel.pages.dev.

The thread logs make the timing unusually concrete. The Codex build prompt started at 23:12:29 BST. The Cloudflare Pages deployment confirmation landed at 23:23:03 BST. Between those two timestamps, Codex made a small interactive explainer, created the Pages project with Wrangler, uploaded the static files, and checked that the deployed page rendered.

The argument was not the artifact

The Discord discussion started in the normal way these conversations start. Someone said wheels do not really arise in biology. We argued about why that might be true, what constraints would matter, and whether any strange mechanism could get around the obvious problems.

We were deliberately not researching it. That was part of the enjoyment. The point was not to end the conversation by pasting a source or asking a model to be the final authority. It was to reason from what we already knew and see where the ideas broke.

Eventually the conversation slowed down. I asked ChatGPT for suggestions, then asked it for a prompt I could give Codex to make the ideas visible.

That second step is the interesting one. Asking for an answer would have produced another paragraph in the chat. Asking for a Codex prompt produced a buildable object.

The prompt asked for five mechanisms:

• a dead keratin or chitin wheel driven by living tissue
• a true living rotating limb with the twisting problem exposed
• a bacterial flagellar-style motor that works at tiny scale but struggles when scaled up
• a detachable or symbiotic wheel with no continuous blood or nerve connection
• whole-body rolling, which is wheel-like but not a wheel-and-axle

It also asked for sliders: wheel size, terrain roughness, tissue connectivity, rotation count, metabolic pressure, and downhill escape mode. Codex turned that into a static app with animated SVG diagrams and live heuristic scores.

The useful threshold is lower than I expected

The project is deliberately plain. The local folder has five files: index.html, styles.css, app.js, package.json, and README.md. There is no backend. There are no external runtime dependencies. The app runs locally with a Python static server and deploys as normal static files.

That shape matters. If this had required setting up accounts, choosing a framework, writing deployment notes, fixing build tooling, and then manually pushing buttons, I probably would not have done it. The discussion would have stayed in Discord, and maybe I would have forgotten the idea by the next day.

Instead, Codex could do the boring edge of the work immediately. It built the page, checked the desktop and mobile layouts, exercised the sliders, verified all five mechanism tabs, fixed the missing favicon noise, and then deployed it with Wrangler.

The deployed version was checked too. Wrangler created the biological-wheel Pages project, uploaded the five static files, and the stable URL returned HTTP 200. A browser check confirmed that the page loaded with all five mechanisms and no console errors.

That is not a grand engineering achievement. That is the point.

The valuable part is that the threshold for making a small public artifact has dropped far enough that it can fit inside the tail end of a casual conversation.

Good enough was enough

The page is not a polished interface. The animation is not perfect. Some of the frontend decisions are exactly the sort of thing I would tighten if this were a serious educational resource.

But the goal was not to publish the definitive interactive museum exhibit on biological wheels. The goal was to make the discussion visible enough that I could send it back to my friends and say: this is the kind of mechanism I meant.

That is a different quality bar.

For this kind of artifact, "good enough" does not mean sloppy. It means the thing has to preserve the shape of the thought. It has to be inspectable, responsive enough to poke at, and honest enough about its limits that nobody mistakes a toy model for proof.

The deployed page does that. It shows why a dead external wheel avoids twisting blood vessels and nerves. It lets the rotation count punish the living-wheel idea. It lets nanoscale size make the flagellar motor plausible and animal scale make it collapse. It gives whole-body rolling a downhill niche without pretending it is a true wheel.

Those are crude sliders, not biology. But they are useful handles.

This is close to what I liked about LLM Choice as an idea engine: the artifact does not need to be the final product. It can be a surface for the next thought.

The workflow changes the conversation

There is a version of AI use that ends a discussion badly. Someone asks a model, gets a confident answer, and treats it as the winner. I do not like that version. It collapses debate into delegated authority, and it often smuggles in errors with a polished voice.

This felt different.

The model did not settle the argument. It made a thing we could argue with.

That distinction is important. A web page with sliders and diagrams is still biased by the prompt, the implementation, and the scoring model. The scoring model in this case is explicitly heuristic. It encodes assumptions like smooth terrain favouring wheel-like motion, tissue connectivity punishing true rotating limbs, and macroscopic size punishing flagellar-style motors.

Those assumptions can be challenged. The page makes them easier to challenge because they are visible.

Maybe the dead keratin wheel should score worse on rough terrain. Maybe the detachable wheel is biologically incoherent. Maybe the whole premise misses known examples. Those are now concrete disagreements to bring back into the discussion.

The artifact does not remove the need for judgement. It gives judgement somewhere to land.

The part I want to keep using

I do not want every stray thought to become a deployed website. Most thoughts do not deserve that. Some should stay in the chat, some should become notes, and some should die immediately.

But I do want to remember this pattern:

• talk through a rough idea
• ask an LLM to turn the idea into a buildable prompt
• let Codex make the smallest useful artifact
• deploy it while the context is still warm
• use the result as conversation material, not as proof

The important bit is the last one. The more capable these workflows get, the more tempting it is to confuse generated artifacts with finished understanding. I think the humbler use is healthier: make the thought visible quickly, then keep arguing with it.

That is what changed last night. A half-formed Discord debate did not become a research paper, a product, or a polished explainer. It became a working page I could send to people.

That is enough to alter the texture of side projects. A thought can be a URL now, and the useful question is not whether every URL is worth keeping. It is whether the next conversation gets sharper because the thought had somewhere to stand.