I kept building the same thing.

Different clients, different industries, different problems — but the work was always the same. Wire up an LLM. Give it tools. Write the handlers. Set up the database. Build the forms. Every project started from scratch, and every project ended the same way: a working agent that could do exactly what we'd hardcoded it to do. Nothing more.

The agents were capable. Impressively so. Until someone asked for something we hadn't anticipated, and we were back in the code. Another migration. Another endpoint. Another week.

But it wasn't just the AI side that repeated. The apps themselves were the same story every time. Forms that collect data. Tables that display it. Emails that go out when something changes. CRUD operations dressed up in different colors. APIs that shuffle JSON between services. Permissions that decide who sees what.

After years of building these things, the patterns stopped being patterns and started being facts. Every app needs a way to store structured data. Every app needs pages. Every app needs notifications. Every app needs roles. The specifics change — the bones never do.

So I asked the real question: what if I took everything I knew about what apps actually need and collapsed it into a set of primitives — building blocks that any AI could assemble on the fly? Not code generation. Not templates. Actual runtime components that compose into real software.

What if the app itself had a brain?

Not an AI bolted onto a traditional app. Not a chatbot pretending to be software. A real app — with a database, pages, forms, automations, user logins — that also has an AI living inside it. One that knows every table, every tool, every workflow. One that can do anything the app can do, because it built the app in the first place.

That was the vision. Not another agent builder. Not another no-code tool. A fusion — a traditional application with a brain. You get the reliability of real software and the flexibility of AI in the same system. The app runs like software. The AI runs like a person who built it and never left.

I called it GenieForge, because the metaphor that stuck was a workshop. You walk in with a wish. You leave with a working machine — one that has an intelligence woven through it.

The first real test was embarrassingly mundane. A task tracker. The AI created a table, wrote four tools, and generated a dashboard page. Eleven minutes. It would've taken me a day.

The second test was where things got interesting. An inventory system — barcode lookups, low-stock alerts, supplier management. The AI got stuck on alerts. It didn't have a way to notify anyone. So I built notifications into the platform. Not for that app specifically — as a primitive any app could use.

Then it happened again. And again. Every app the AI tried to build exposed something the platform was missing. And every time I filled a gap, every future app got easier to build. The platform was learning what it needed to be — through the act of being used.

One night I was keeping a list of things that needed to be built. Scrolling through it, I realized something obvious: the AI was the one finding these gaps. Every time it hit a wall, that was a signal. I was just the one writing it down.

So I stopped writing it down. I built another agent — one whose job was to inhabit other apps, feel their limitations from the inside, and file structured proposals for what the platform needed next. Not from reading docs. From living the experience.

It analyzed one app and came back with twenty-six proposals. Each one cited specific tools, specific code, specific moments where the platform fell short. I built them all.

The thing I built was now telling me what to build next.

It filed proposals to improve its own tools. It noticed its list was truncating and asked for pagination. It couldn't update priorities after filing, so it asked for that too. It wanted batch operations, fuzzy duplicate detection, a lighter-weight inspection mode.

I sat there reading proposals that an AI had written about its own limitations, using a tool it had asked me to build, running on a platform it was actively helping me improve. The recursion was dizzying.

Somewhere in there it became better than I'd imagined. I always meant it to be this — a platform where you describe what you want and an AI builds and runs it. That was the vision from day one. What I didn't expect was how well it would actually work.

People describe what they want. An AI builds it — the database, the tools, the pages, the automations. Their users get logins. Push notifications land on phones. Scheduled tasks fire at 3 AM. The AI stays inside the app and keeps running it, getting smarter with each conversation.

The vision was always there. The surprise was that it delivered on it.

It's still happening. New apps expose new gaps. The AI still files proposals. I still build them. The loop keeps turning — a little faster each time, a little smarter each time.

Someone walks up to a blinking cursor with a problem, describes it in their own words, and walks away with something that works. Everything else is just the forge doing its job.