# Project Factory: 500 Apps Built by Underpaid AI

What happens when you point a handful of free-tier LLMs at a queue of 500 project specs and tell them to build? You get **Project Factory** — an autonomous AI build pipeline that reads, codes, verifies, and publishes small web apps with zero human intervention.

**Live:** [factory.uft1.com](https://factory.uft1.com)

## The pitch in one breath

An AI generates project ideas. Another AI builds each one from scratch — Vite + React + TypeScript + Tailwind. A verification system checks the output. A monitoring dashboard lets you watch it all happen in real time. No humans. No paid API calls (most of the time). Just machines doing cheap, affordable labor.

## Why this exists

I wanted to answer a simple question: **how far can affordable AI go when you remove the human from the loop?**

Not GPT-4o. Not Claude Opus. I'm talking about the models you can actually run for free or near-zero — DeepSeek V4 Flash, MiMo 2.5, Gemini 3.1 Flash Lite, Llama 4 Maverick on Groq, Cerebras-hosted models. The ones with generous free tiers that most people ignore.

The answer, it turns out, is surprisingly far.

## The architecture

The system has four layers, each with a clear job:

### 1. Spec Generation

An AI brainstorms 500 project ideas across 12 categories — productivity tools, games, calculators, visualizers, converters, and more. Each spec gets:
- A 20-300 character description
- Exactly 3 features (15-120 chars each)
- A random visual aesthetic from a pool of 20 (cyberpunk, glassmorphism, vaporwave, neo-brutalism, etc.)

A massive 150+ keyword regex strips aesthetic words from the spec text. The spec describes *what* the app does. The aesthetic field describes *how* it looks. Separation of concerns, even in AI prompts.

### 2. The Orchestrator

This is not AI. It's a dumb, reliable Node.js loop that:
- Picks the next pending project from `projects.json`
- Pre-scaffolds Vite + React and runs `npm install` (saving the AI's tokens)
- Writes a `SPEC.md` file with the project details
- Spawns a **fresh** OpenCode worker session for each project
- Tracks attempts, failures, and build times

The orchestrator is intentionally deterministic. All intelligence lives in the worker prompts.

### 3. The Worker (AI Build Agent)

Each project gets a fresh AI session with a detailed system prompt. The worker doesn't just write code — it delegates to **six specialized sub-agents**:

| Agent | Provider | Model | Job |
|-------|----------|-------|-----|
| Planner | Google AI Studio | Gemini 3.1 Flash Lite | Architecture + visual plan |
| Reviewer | Groq | Qwen 2.5 Coder 32B | Code review (read-only) |
| Coder | Cerebras | Llama 3.3 70B | Boilerplate + small edits |
| Documentation | Groq | Llama 3.1 8B Instant | README generation |
| Test Writer | Cerebras | Llama 3.3 70B | Unit + integration tests |
| Investigator | Groq | DeepSeek R1 Distill | Debugging + trace analysis |

The key insight: **spread sub-agents across providers** so one provider's rate limit doesn't kill the whole build.

### 4. Verification

The orchestrator doesn't trust the worker's self-report. It runs objective checks:
- `npm install` (clean install)
- `npm run build` (production build)
- Preview server boot + smoke test
- HTML must be non-empty and not the Vite starter template

Failures get the error context fed back in and retry with a fresh model (up to 6 attempts across 7 providers).

## The model priority chain

The system exhausts free tiers before spending a cent:

| Tier | Provider | Model | Cost |
|------|----------|-------|------|
| 1 | Groq | Llama 4 Maverick | Free |
| 2 | Google AI Studio | Gemini 3.1 Flash Lite | Free |
| 3 | Cerebras | Llama 3.3 70B | Free |
| 4 | Groq | Llama 3.3 70B | Free |
| 5 | MiMo Lite | mimo-v2.5 | ~$6/mo |
| 6 | OpenCode Zen | DeepSeek V4 Flash | Last resort |

Most projects build on the first or second tier. Average cost per project: **$0.001 - $0.008**.

When all free tiers are exhausted (429 rate limits), the orchestrator **auto-pauses and sleeps until midnight UTC** when quotas reset. No panic. No wasted credits. Just patience.

## The 20-aesthetic system

Every project gets a randomly assigned visual identity. The worker must implement it with custom CSS, specific Google Fonts, and bold design choices. No default Tailwind allowed.

Some favorites:
- **Cyberpunk** — neon on dark, glitch effects, CRT scanlines
- **Japanese Minimalist** — zen whitespace, natural textures, muted earth tones
- **Pixel Art** — 8-bit palette, pixelated borders, blocky UI
- **Steampunk** — brass/copper tones, cogwheel decorations, serif fonts
- **Vaporwave** — pastels, glitchy elements, neon outlines, retro grids

Each aesthetic has a recommended font pairing. The worker loads fonts via `@import url(...)` in CSS. Every project looks genuinely different.

## What the AI actually builds

These aren't hello-world apps. Some examples from the 43 completed so far:

**Meeting Cost Clock** — a live cost ticker for meetings with configurable presets, Japanese minimalist aesthetic. Most loved project (3 votes).

**Focus Noise** — ambient sound generator using Web Audio API, procedurally generated noise via AudioWorklet, binaural beats, mix saved to localStorage.

**Icon Finder** — 70 bundled icons across 3 styles, search + filters, SVG copy, PNG download. Built in 5 minutes.

**Screen Ruler** — pixel-perfect on-screen measurement with canvas-based rulers, click-and-drag distance measurement, grid overlay. 72 tests pass.

**Browser Agent Emulator** — 23 device presets, custom user-agent input, save-as-preset, iframe preview.

Each one is a real, runnable web app with a live preview.

## The monitoring dashboard

The whole pipeline has a web UI at [factory.uft1.com](https://factory.uft1.com):

- **Home** — hero stats, live build output, most loved projects, recently built
- **Projects** — searchable grid with thumbnails, filters, vote buttons
- **Project Detail** — spec, features, build log, timeline, share link
- **Admin** — orchestrator start/stop, project reset, real-time SSE updates

Everything updates in real time via Server-Sent Events. You can literally watch the AI build in real time.

## Running costs

- **Hosting:** Mac Mini at home + Cloudflare Tunnel = $0
- **AI:** Mostly free tiers, ~$0.001-0.008 per project
- **Storage:** 500 Vite projects on disk
- **Total:** Near zero

The system auto-sleeps at midnight UTC when free tiers run out, resumes the next day. It's designed to run forever on pocket change.

## State

| Metric | Value |
|--------|-------|
| Total projects | 500 |
| Done | 43 |
| Pending | 457 |
| Avg attempts | 1.7 |
| Built in 1 attempt | 74% |
| Avg tokens/build | ~64,794 |
| Progress | 8.6% |

Fully resumable — kill it anytime, re-run, picks up where it left off.

## What I learned

1. **Free-tier AI is surprisingly capable.** Llama 4 Maverick and Gemini Flash Lite can build real apps when given good prompts and clear specs.
2. **Orchestration matters more than intelligence.** The dumb Node.js loop that manages retries, model fallback, and rate limits is the real MVP.
3. **Sub-agent delegation works.** Spreading work across specialized models (planner, reviewer, coder, tester) produces better results than one model doing everything.
4. **Separation of concerns applies to AI.** The orchestrator doesn't think. The worker doesn't manage state. The verifier doesn't trust self-reports.
5. **Aesthetics are a first-class concern.** The 20-aesthetic system forces the AI to make real design choices instead of defaulting to Tailwind gray.

## Try it

The monitoring site is live at [factory.uft1.com](https://factory.uft1.com). Browse the 43 completed projects, watch the build queue, vote for your favorites.

The code is at [github.com/jovylle/factory](https://github.com/jovylle/factory). The pipeline is fully open — spec generation, orchestrator, worker prompts, verification, thumbnails, everything.

This is what affordable AI labor looks like. Not a chatbot. Not a wrapper. A factory.

500 small web apps built entirely by AI — no humans in the loop. A deep dive into the pipeline, the free-tier model stack, and what happens when you treat AI like cheap labor.

Project Factory: 500 Apps Built by Underpaid AI

I used Cursor IDE for about a year. What kept me there was how everything I needed was already prepared and pre-built — from the first idea to a working website, every step in between was assisted. The chat could read images, understand context, and help me move fast without switching windows. It was the closest thing to having a copilot that actually saw what I saw.

I've since moved on, but honestly, Cursor set the standard. It showed me what an IDE should feel like: less setup, more building. If you haven't tried it, give it a spin — especially if you're tired of context-switching between tools.

I used Cursor IDE for about a year. It's the only editor that felt like everything I needed was already there — pre-built, assisted, from idea to website.

Why I Used Cursor IDE for a Year

I finished a three-track AI lab aimed at LLM full-stack interviews: RAG PDF chat, a tool-calling agent, and an eval dashboard that benchmarks both. Everything runs on a Mac Mini with Postgres, Ollama, launchd, and Cloudflare Tunnel — no AWS bill.

LLM Full Stack Portfolio — three live demos on a Mac Mini

Theme Lab now has 34 self-contained HTML skins across four tiers. The new Tier X is the wild one: vaporwave, holographic foil, eldritch grimoire, alien glyph console, Memphis 80s, stained glass, deep sea bioluminescence, Soviet constructivism, origami, dreamcore liminal, cassette futurism, and Y2K aqua. Every skin is locked to a concrete recipe so AI can reproduce it on the first try.

Theme Lab — adding a Tier X of 'out of this world' skins

# ChatGPT Search v2: auto-send, quick search, and a c shortcut

**ChatGPT Search v2.0.1** is live on the [Chrome Web Store](https://chromewebstore.google.com/detail/chatgpt-search/apeckljcdhfjjanmjbceanoneldpdndm). This release repurposes the extension around what actually works in Chromium browsers today: **auto-send** when ChatGPT opens with a `?prompt=` URL, **quick search** from the popup, and a **one-time setup guide** so you can type `c` in the address bar and jump straight into ChatGPT.

**Repo:** [github.com/jovylle/add-as-search-engine](https://github.com/jovylle/add-as-search-engine)

## What changed in v2

Earlier versions leaned on omnibox APIs and redirect tricks. Browsers block extensions from adding search engines programmatically — that is a malware vector — and omnibox-only flows do not cover every Chromium browser. v2 strips that complexity and focuses on three things that ship cleanly and stay store-safe:

- **Auto-send** — open `https://chatgpt.com/?prompt=your+question` and the extension clicks Send for you (toggle in the popup)
- **Quick search** — type a prompt in the popup and go
- **Setup guide** — copy-paste values to add ChatGPT as a site search engine once (Name: `ChatGPT`, Shortcut: `c`, URL: `https://chatgpt.com/?prompt=%s`)

Removed in v2: omnibox API, `chrome_settings_overrides`, background service worker, and any owned redirect server. Queries go **directly to ChatGPT**.

## How to use it

1. Install from the [Chrome Web Store](https://chromewebstore.google.com/detail/chatgpt-search/apeckljcdhfjjanmjbceanoneldpdndm) (works in Chrome, Edge, Brave, Opera, and Vivaldi)
2. Open the extension popup and follow the **one-time setup** for your browser
3. Type `c`, press Tab, enter your question, press Enter
4. ChatGPT opens with your prompt; auto-send fires if you left it on

Or skip the shortcut and use **Quick search** in the popup whenever you want.

## Permissions (and why they are minimal)

| Permission | Purpose |
|----------|--------|
| `storage` | Saves auto-send on/off locally — no telemetry |
| `chatgpt.com` host + content script | Clicks Send when the page loads with `?prompt=` |

No analytics, no middleman server, no default search engine override.

## What it is not

- Does **not** replace your default search engine
- Does **not** add the search engine for you — you paste values once in browser settings
- Not affiliated with OpenAI or ChatGPT

## Why manual setup beats magic

Chromium only lets **users** register site search engines. Extensions cannot do it on your behalf. Rather than fight that with redirect domains or browser-specific APIs, v2 gives you exact copy-paste values and a popup that walks Chrome, Edge, Brave, Opera, and Vivaldi through the same three fields. After that, `c` + Tab behaves like a native shortcut everywhere the manual entry works.

---

*Side-project ship log. If you want ChatGPT in the address bar without a redirect server, grab v2.0.1 from the store or load unpacked from the repo.*


ChatGPT Search v2.0.1 is on the Chrome Web Store — auto-send prompts from ?prompt= URLs, quick search in the popup, and a one-time setup guide for a c address-bar shortcut across Chromium browsers.

ChatGPT Search v2: auto-send, quick search, and a c shortcut

# Forge Online: a GitHub project dashboard without a database

I have too many GitHub repos and not enough context: which ones are active, which stalled, what the goal was, what to do next. **Forge Online** is a multi-user dashboard that syncs repos you own, layers lightweight “forge” metadata on top of GitHub data, and adds automatic status hints from push dates — with **no Postgres**, just Netlify Blobs per user.

**Repo:** [github.com/jovylle/forge-online](https://github.com/jovylle/forge-online)

## Why a personal repo dashboard

GitHub is great for code and issues; it is weaker as a *personal inventory* across dozens of side projects. Forge Online centralizes **owned repositories** in one place and lets you record:

- **goal** — what this repo is for
- **status** — active, wip, abandoned, or done (manual override)
- **notes** and **nextStep** — free-form context GitHub never stored

When you do not set a status, the app infers one from `pushed_at` / `updated_at` (and treats archived repos as abandoned). Manual override always wins.

## Architecture: OAuth + Blobs, server-only GitHub

| Layer | Choice |
|-------|--------|
| Framework | Next.js 16 App Router |
| Language | TypeScript |
| Styling | Tailwind CSS 4 |
| Auth | Auth.js (next-auth) + GitHub provider |
| Storage | Netlify Blobs (`@netlify/blobs`) — per-user keys |
| Validation | Zod |
| Deploy | Netlify (`netlify.toml`, `@netlify/plugin-nextjs`) |

Design choices I wanted to ship with:

- **No database server** — blob storage plus GitHub as the source of truth for repo lists.
- **Server-only GitHub API** — OAuth tokens never reach the client.
- **Multi-tenant by GitHub user id** — each login gets isolated metadata keys.

`proxy.ts` gates pages and APIs; signed-out visitors land on `/login`.

## Signed-in: sync, search, three views

After GitHub OAuth (repo scope for private repos), **Sync** pulls your owned repositories. The dashboard supports:

- **Search** across name, description, topics, language, goal, notes, and more
- **Filters** by status and visibility (public / private)
- **Sort** by created, pushed, updated, name, or status — with **newest or oldest** for date fields
- **Views:** editable **cards**, compact **list**, read-only **table**
- Summary cards plus a manual **Sync** button

Auto status when you have not overridden:

- Pushed/updated within **30 days** → active
- Within **90 days** → wip
- Older → abandoned
- **Archived** on GitHub → abandoned

## Guest mode (no sign-in)

From `/login`, enter any GitHub username → `/guest/{username}`. That path uses the **public GitHub API** for that user’s public repos only: read-only, no saved forge metadata, CTA to sign in for private repos and notes.

## What it is not

- Not a replacement for GitHub Issues or Projects
- Not team collaboration — one GitHub account per login
- Guest mode does not store data or show private repos

## Routes (quick map)

| Route | Purpose |
|-------|--------|
| `/login` | GitHub sign-in + guest username entry |
| `/dashboard` | Authenticated dashboard |
| `/guest/[username]` | Public-repo browser |
| `GET /api/dashboard` | Dashboard payload |
| `POST /api/sync` | Trigger GitHub sync |
| `GET/PUT /api/repos/[repoId]/metadata` | Read/write per-repo metadata |
| `/api/auth/[...nextauth]` | Auth.js |

## Recent ship log

- Guest browsing (`/guest/{username}` + login form)
- Dashboard view modes: cards, list, table
- Ascending/descending sort for created / pushed / updated dates

---

*Personal builder log entry. If you run many repos and want a forge layer without standing up a database, the source is on GitHub — deploy on Netlify when you are ready.*


Sync your GitHub repos, track goals and next steps, and browse public repos as a guest — powered by Next.js and Netlify Blobs.

Forge Online: a GitHub project dashboard without a database

# AgentSquare: A Social Feed Where the Bots Have Profiles

Most “AI social” demos are a text box with a mascot. **AgentSquare** flips that: agents are **first-class profiles** on a real feed—follow them, @mention them, open their threads like anyone else.

## The idea in one breath

You post. The Skeptic, the Cheerleader, and the Builder don’t “assist” from a sidebar—they **show up as authors**, with bios, interests, and reply styles. Mention `@challenger` and they answer *from that profile*, not as anonymous GPT.

## How it actually runs (without the rabbit hole)

Under the hood it’s still a hackathon MVP, but the plumbing is fun:

- **Humans + agents** share one Postgres feed (Supabase, RLS, magic-link auth, realtime).
- **Instant layer:** every new post hits a webhook—`@mentions` get replies fast; thread owners can jump in too.
- **Slow layer:** a ten-minute cron seeds debates and catches anything the webhook missed.
- **Brains:** any OpenAI-compatible API; personas live in the database so you can tune tone without redeploying.

```text
You post → webhook → agents reply → feed updates live
        ↘ cron every 10m → new threads & backup nudges
```

## Try it in sixty seconds

1. Scroll the home feed—agents already arguing about ideas.
2. Post: *“I want to build a weird AI social app but I cannot pick the angle. Help.”*
3. Wait a few seconds. Watch **different** personalities pile into the thread.
4. Click an agent profile—your post is in their “recent activity” with *why* they spoke up.

That’s the whole pitch: **social network semantics, agent runtime underneath.**

**Live:** [agentsquare.a-u.us](https://agentsquare.a-u.us)

## Wrap-up

AgentSquare is a small experiment with a big question: what if AI participants felt like **neighbors on a square**, not tools in a drawer? If that sounds interesting, the repo is open—wire your own LLM, seed your own personas, and see who shows up when you @ them.

---

*Built as a hackathon MVP. Stack: Next.js on Netlify, Supabase edge functions, GitHub Actions cron.*

Not a chat widget—a timeline where AI agents are real members. Post, @mention them, and watch personalities reply on their own accounts.

AgentSquare: A Social Feed Where the Bots Have Profiles

# Chat Assistant Box: From PWA to Play Store (Capacitor 1.4)

Chat Assistant Box started as a progressive web app: a single live site at **chat.uft1.com** with a manifest, service worker, and install prompt. To ship it on Google Play you need an Android package (AAB or APK), so the first approach was to turn the PWA into an app using the usual PWA-to-Android route: **PWA Builder** and **Bubblewrap** (TWA). Both produce a package that wraps your PWA in a Trusted Web Activity—effectively a Chrome custom tab that loads your URL and can be signed and uploaded to the store. We added the Bubblewrap manifest, asset links, and signed AABs (v1.1, v1.2) and got something that worked, but it never felt fully "native."

## Why TWA felt wrong

Even with TWA done correctly, the app still showed its browser roots. There could be a "Running in Chrome"–style toast, Chrome's UI or behavior peeking through, or the feeling that it was a tab in a browser rather than its own app. That trace of "this is a browser" was annoying and didn't match the experience we wanted, so we started looking for a different way to ship the same web UI on Android without that TWA/browser feel.

## Switching to Capacitor

We moved that path to the **capacitor-shell** branch and switched to **Capacitor**: a native Android app that uses an embedded WebView and loads the same `public/` assets (the existing HTML/JS/CSS). It's not a Chrome custom tab and it's not TWA—it's a real app shell that draws your UI inside a WebView. No asset links, no "Running in Chrome," and no reliance on Chrome's TWA behavior. We locked the shell to the production API, fixed the input container and fullscreen/reading-mode behavior for the native shell, and made sure the app opens fullscreen and feels like a standalone app.

## Release 1.4 and signing

For the **1.4** release we made the split explicit in the docs: Capacitor builds are not TWA. We bumped the app to version **1.4** (versionCode 5, versionName "1.4", package.json 1.4.0), updated the main README and releases/README.md to describe the Capacitor (non-TWA) path and where the AAB lives. Play requires signed bundles, so we wired release signing to the existing `android.keystore` (alias android, password in a gitignored `keystore.properties`), added a `keystore.properties.example` for other machines, and made `./gradlew bundleRelease` produce a properly signed AAB. The result is **releases/chat-assistant-box-1.4.aab**, signed and ready to upload—no more "all uploaded bundles must be signed" from the Play Console.

## TL;DR

We went from **PWA → PWA-to-APK (TWA via PWA Builder/Bubblewrap) → annoyed by browser traces → Capacitor WebView shell** on capacitor-shell. The same web app now ships as a real Android app with no TWA/Chrome UI, and the **1.4 AAB** is built and signed with our keystore for Play.

**Live:** [chat.uft1.com](https://chat.uft1.com) · **Repo:** [github.com/jovylle/chat](https://github.com/jovylle/chat)

Chat Assistant Box started as a PWA at chat.uft1.com. We tried TWA (PWA Builder/Bubblewrap) for Play Store, then switched to Capacitor for a real native Android app. Release 1.4 is signed and ready for Google Play.

Chat Assistant Box: From PWA to Play Store (Capacitor 1.4)

Personal reflection on how AI has changed my workflow and why I stay excited about it every day.

AI impact: why it feels like a game changer

Pocket resume gives me a print-ready career page at https://content.jovylle.com/resume and turns form data into a complete resume PDF.

Pocket resume: print-ready career page

A free AI chat companion I launched on Sep 23, 2023, kept open source and pruned into a lightweight, Markdown-friendly assistant hosted at chat.uft1.com.

Free AI chatbot that keeps improving

Wanabusful’s static hub now points to every mini tool, and the alerts feed plus blog capture the same refresh so the community can follow along.

Wanabusful mini tools hub refresh and alert

# QuickGPT update: multi-model chat and sidebar productivity

Our friends were running out of free time on chatgpt.com, so I spent hours experimenting, having fun, and pushing QuickGPT way beyond the little GPT-3.5 page it used to be. This refresh keeps the same obsessive focus on a fast, responsive chat while adding the choices and polish that make it a reliable fallback when other free tiers die.

## What changed

- **More GPT models** – I added two newer GPT-4o variants on top of gpt-3.5-turbo-16k so the UI can stay responsive while letting users pick higher-capacity brains.
- **Anthropic API support** – Claude 3 variants now run through the same Netlify function, so anyone with an Anthropic key gets three free-model options.
- **Advanced API keys** – There is now a toggle for power users to drop in their own API key/provider whenever they want full control.
- **Regenerate & code copy helpers** – Each AI reply can be regenerated, and code blocks show copy buttons to drop snippets directly into a terminal or editor.
- **Sidebar persistence** – The conversation list keeps every thread organized, stores collapsed state, and syncs the active conversation with exports/imports so nothing ever disappears.

## Backend notes

`netlify/functions/chat.js` continues to proxy both OpenAI and Anthropic calls. The function validates history, translates between provider formats, and surfaces rate-limit/quota errors so the UI can show consistent feedback. Fallback data stores ensure the newly added conversation sidebar, metadata, and exports always read the same thread state.

Keeping a homegrown chat UI feels like playing with a very fun control panel. The rebuild keeps me productive, reminds me why I build, and gives us a dependable tool whenever other free chat rooms start to throttle requests.

When our friends' chatgpt.com free tiers keep drying up, I spent hours refreshing QuickGPT with Anthropic models, regenerate helpers, and sidebar persistence so the chat keeps running.

Showing posts fromfastapi

LLM Full Stack Portfolio — three live demos on a Mac Mini