I Put AI in the Presentation Layer. That’s Where It Belongs.

Weather With Regerts started as a joke. It has since accumulated thousands of phrases, themed packs, validation rules, deterministic selection, runtime reloads and enough engineering that the joke itself may now qualify as technical debt.

It also accidentally became one of the cleanest examples I have of how I think AI should be used.

The weather integration does not ask an AI whether it is hot outside. That would be insane. Home Assistant already has weather providers and sensors capable of telling me the temperature. The thermometer does not need a creative writing partner.

The facts come from deterministic sources. The personality comes afterward.

That separation matters far beyond weather jokes.

Truth first, personality second

If the temperature is 106°F, that value is the ground truth available to the system. Code can classify it into a temperature band. Conditions can be combined with humidity, wind or precipitation. Then a presentation layer can select something more entertaining than the sterile output a normal weather application would display.

The result might tell me that “the sun has chosen violence.”

Great.

But the joke never gets a vote on whether it is actually 106°F.

This is an architectural pattern I wish we used more often with AI. Let conventional systems establish facts whenever conventional systems can establish facts. Give AI authority over interpretation, summarization, presentation or creativity only to the degree that the application can tolerate uncertainty.

Creativity without authority

There is an enormous amount of useful territory between “don’t use AI” and “let the model run the company.”

A model can draft a customer update from known transaction state without being allowed to change that state. It can summarize an incident without being allowed to close it. It can identify unusual records for a human to inspect without being allowed to punish the person associated with them. It can make a weather report funny without being allowed to control the thermostat.

That is creativity without authority.

It is also much easier to reason about operationally. If the generative layer produces nonsense, the underlying facts remain intact. The system can fall back to a boring representation. A bad joke is annoying. A hallucinated temperature controlling safety logic is an architecture problem.

Ground the model in things you already know

People sometimes describe grounding as though it is an exotic AI technique. At the application level, the principle is straightforward: don’t ask the model to invent information the system already possesses.

If the database knows the customer name, provide it. If the transaction system knows the appointment time, provide it. If a sensor knows the temperature, provide it. If the system does not know something, preserve that uncertainty instead of inviting the model to fill the hole with something linguistically plausible.

Plausibility is what language models are exceptionally good at. Unfortunately, reality has no obligation to be plausible.

Weather With Regerts can fail safely because the stakes are tiny

Part of the reason this project is fun is that the consequences of creative failure are wonderfully low. If a Star Trek phrase appears when I expected a Dungeons & Dragons reference, nobody loses their house. If ChatGPT contributes something completely deranged to the phrase database, I get another entry for the “WTF did Chat put in the database?” collection.

That makes it an excellent playground for experimenting with generative behavior.

But the architecture still matters. The integration keeps source facts separate from commentary. Phrase packs can be enabled independently. User overrides load predictably. Runtime reloads do not require the entire Home Assistant instance to restart. The active database can tell me where a phrase came from.

I may be making the weather swear at me, but I would still like reproducible builds.

Put uncertainty where you can afford it

That is probably the broader rule.

AI is probabilistic. Instead of pretending otherwise, design the application so the probabilistic part lives somewhere uncertainty is acceptable.

Use deterministic code for authorization. Use authenticated records for identity. Use transactions for money. Use sensors for measurements. Use explicit state machines for workflows where transitions matter.

Then use AI where its flexibility is actually valuable: language, discovery, summarization, classification with review, creative interfaces and assistance.

The presentation layer is not the only safe place for AI, obviously. But Weather With Regerts demonstrates the principle in a way I find difficult to forget.

The computer is allowed to tell me that Tatooine is cooler right now.

It is not allowed to decide whether the air conditioner should save my life.