Not another app builder. A personal software foundry.

Make exactlywhat you need.

Lovable for you, not fake SaaS. Describe a planner, calculator, guide, game, tracker, decision room, or tiny personal app. Use it immediately. Change it by talking. Keep it as one self-contained file.

Use the live examples ↓
need → describe → use → reshape → keep   No deployment theater required.
personal foundry / local session
apartments.htmlready to use
HTML

Apartment decision room

A shared, weighted comparison built around your actual priorities—not a generic property app.

weighted scorecommutebudgetnotesshortlist
1 filethe actual object
0 loginsto open it
offlineby default
forkablesend a copy
KBthis entire interactive argument
elements, all inside this file
external requests at load
onlinethe file does not care
01 / the inversion

One user makes many pieces of software for themselves.

Traditional builders assume a product, a market, and many users. This starts with a person, a moment, and one stubborn need.

The normal builder loop

Build a product for other people.

The output is shaped like a software business even when the original need was tiny.

  1. builder
  2. product
  3. users
Software for one

Manufacture the missing interface at the point of need.

The output can live for ten years or ten minutes. Its job is to be useful, not become a company.

  1. person
  2. need
  3. artifact
“Make the app you would never download, subscribe to, or ask a developer to build.”
AI-powered property synergy
I just need to choose the right apartment with my partner.
landing pageauthenticationuser profilespricing tiersanalyticsdatabaseadmin dashboardnotificationscustom domaingrowth funnel
HTML
apartments.htmlOpen it. Use it for three weeks. Archive or delete it.
02 / the medium

The browser is the reader. AI is the editor. HTML is the bytecode.

AI removes HTML’s old weakness: people hate maintaining it by hand. The browser already supplies layout, controls, graphics, media, printing, accessibility primitives, storage, and a remarkably durable runtime.

one container, many forms

Slide from document to software.

The person starts with a need, not a medium. A guide can become a planner. A memo can become a simulator. A birthday page can become a game.

documentadaptive objectsoftware

Adaptive artifact

A readable explanation with live controls, embedded data, and a shape the recipient can change after receiving it.

  • read like a document
  • probe like a tool
  • fork like a file
BROWSER = READERUniversal opening, rendering, interaction, print, and offline use.
AI = EDITORNatural language becomes layout, logic, data views, and targeted patches.
HTML = BYTECODEThe implementation format can stay invisible while the artifact stays ownable.
03 / working proof

Situational software, not software-development role-play.

These are deliberately small. They exist for a decision, a trip, a learning session, or a night with friends. That is enough.

Choose with your actual priorities.

Change the weights. The recommendation changes immediately. No generic apartment platform knows your tradeoffs this precisely.

apartments.html

Your shared priorities

A guide that adapts to the day.

One trip object can hold confirmations, preferences, accessibility constraints, budgets, and a rainy-day branch.

family-trip.html
4 days · 5 people

Turn notes into a tiny learning environment.

The document is no longer the end of the workflow. It can quiz, explain, adapt, and track where you are weak.

biology-study-room.html
0/3

Correct answers in this round.

Question 1 of 3
Question 01

Choose an answer.

Software can be disposable and still be delightful.

Make a game for one birthday, one group, one night. It never needed a roadmap.

mina-30.html
Press “Deal a prompt” to start the room.
ready when you are
04 / the consumer loop

Making and using collapse into the same motion.

The person should leave “builder mode” as quickly as possible. The result becomes the interface; conversation remains available whenever reality changes.

01 / Need

Begin with an awkward little problem, not an app idea.

“We have six apartment listings, two commutes, a budget, and different priorities.” That is enough. The system should infer the useful interface without asking the person to become a product manager.

REALITY: messy links + two opinions + a deadline
05 / collaboration without the detour

Send, fork, change, merge.

Perfect real-time multiplayer is not required to prove the medium. A file already has a native collaboration model: copies. AI can make the differences legible.

1Send the artifactYour partner opens a working copy.
2Fork naturallyNo permission ceremony; their copy is theirs.
3Change by talking“Make commute twice as important.”
4Review meaning, not codeAccept a semantic diff.
partner-fork → your-copyno changes loaded
changedCommute importance: 3× → 5×
addedConstraint: must allow a cat
addedView: separate scores for each partner
changedBudget ceiling: $2,800 → $3,000
06 / the durable product

A personal shelf of little tools.

The individual artifacts can be temporary. Retention comes from a new confidence: whenever an awkward problem appears, you can manufacture the exact software you need.

Click a file to archive or restore it. Your additions are saved locally in this browser.

07 / the category line

Close to existing AI builders. Different default.

The important distinction is not whether each tool can technically emit HTML. It is what the product assumes the person is trying to accomplish.

Default assumptionLovableClaude DesignSoftware for one
What are you making?An app, website, or digital product.Polished visual work, designs, prototypes, slides, or one-pagers.The exact interface this situation needs.
Who are you in the loop?A builder or team shipping to users.A creator collaborating on a canvas.The person who needs the thing right now.
Canonical objectA development project and deployed experience.A design project; HTML can be an output.A user-owned, self-contained artifact.
Default lifespanProduct-shaped and ongoing.Project-shaped and revisable.Ten minutes, three weeks, or ten years.
Backend gravityAvailable and often appropriate for production apps.Secondary to the visual artifact.None unless the need genuinely demands one.
SuccessBuild, refine, and ship a working product.Create and iterate on polished visual output.Solve the need, hand over the object, disappear.

Positioning summary, not a complete feature audit. Product descriptions checked against official pages in July 2026: Lovable and Anthropic’s Claude Design announcement. Links are inert until clicked; this page makes no external request on load.

08 / honest boundaries

A better default is not a replacement for everything.

The format is strongest when the artifact should be finished, portable, inspectable, and useful without a permanent service wrapped around it.

Reach for one-file software when…

The need is intensely personal or situational.
The recipient should be able to read, calculate, sort, simulate, or adapt.
Offline use, archiving, forwarding, and long-term ownership matter.
The object can carry its data and logic comfortably inside one file.

Use shared services or real apps when…

Many people must edit the same state simultaneously.
Strict access control, audit policy, or regulated workflows dominate.
The dataset is huge, fast-changing, or must stay server-authoritative.
Legal fixity or exact print reproduction is the primary requirement.

The strongest hybrid

Canonical webpage + downloadable self-contained HTML snapshot + print/PDF. The live page handles updates, the one-file artifact handles ownership and offline use, and PDF handles formal printing or fixed records.

The real tradeoffs stay visible: embedded media can make files large; JavaScript deserves a clear safety posture; duplicated assets do not update centrally; and browser-specific behavior should degrade gracefully. Those are design constraints—not reasons to keep freezing interactive information into screenshots.

09 / what becomes defensible

Generation gets cheap. Trust becomes the product.

A disposable AI webpage is easy. A dependable, portable information object needs structure, provenance, safety, and graceful survival.

01 / STRUCTURE

Stable blocks, not DOM soup.

The AI edits a semantic model with durable IDs, then applies targeted patches.

section:decision.criteria
02 / PROVENANCE

Claims know where they came from.

Data, sources, assumptions, and AI-generated text remain inspectable inside the artifact.

source → claim → view
03 / DETERMINISM

Calculations stay calculations.

Numbers are recomputed by explicit logic, not improvised again every time someone opens the file.

inputs + rules = result
04 / SURVIVAL

The object outlives the service.

Readable without JavaScript, no network by default, printable, local-first, and exportable at any time.

service gone ≠ file gone

Software should be abundant enough to be personal, malleable enough to be situational, and portable enough to be yours.

Not every need deserves a startup. Every person deserves the ability to make the missing tool.

A self-contained HTML file can be media and software at once. AI lets consumers create either without deciding which one they are making.
10 / the first sharp product

Describe, use, reshape, export.

Start with a wedge where generic apps fail because the inputs and tradeoffs are intensely personal: decisions, plans, comparisons, learning, and one-off social experiences.

The first loop

Drop in messy notes, documents, links, images, or data. Receive one polished artifact. Edit it while using it. Inspect the semantic diff. Keep one file.

01Ingest the person’s real context, not a blank app brief.
02Generate the smallest finished interface that solves the situation.
03Let natural language patch structure, logic, appearance, and data.
04Export by default; publishing to a URL remains optional.