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

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:

• 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. Browse the 43 completed projects, watch the build queue, vote for your favorites.

The code is at 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.