Same setup, but the AI drives the dashboards it cannot reach through an API. Everything that has a working API still runs as a normal command — the browser is used only for the handful of screens, chiefly Google’s OAuth consent screen, that no API can configure.
Experimental — not tested⚠️ Experimental — this may or may not work. Not tested.
Nobody has run this page end to end. It is written from what the tools claim they can do, not from a completed setup. Expect it to stall somewhere, and expect to finish that part by hand.
If you want the path that is known to work, use the normal setup. Come back here if the Google Cloud console defeats you — that is the step this exists for.
It is a starter kit that gives an AI chatbot a real place to work.
On its own, a chatbot can only talk. It cannot save anything, cannot put a page on the internet, cannot remember what you did last Tuesday, and cannot touch anything on your computer. Every conversation starts from nothing.
This setup hands it the missing pieces: a database to remember things, a website anyone can visit, an email sender, file storage, a login system, and a copy of everything on your own machine. All of it wired together and all of it yours.
You do not assemble any of that. You paste one prompt, answer questions in plain language, and the AI chatbot builds it while you watch. Most people are done in about two hours.
This is the part that surprises people. The AI chatbot is not stuck behind a text box — it runs on your machine, with your permission, and can act on what it finds there.
You approve what it does. It is not running loose — it asks, you say yes, and it stops when you tell it to.
The output is a live URL, not a suggestion you still have to implement.
Ask for a change and it is live in minutes. That loop — say it, see it, adjust it — is the thing that makes people keep going.
Almost anything with an API can be wired in, and the AI chatbot does the wiring.
Each one is a conversation, not a project. You say what you want connected; it handles the keys, the plumbing, and the testing.
Most tools force a choice: a work tool, or a personal one. This is neither, because it is not built around a use case — it is a general workshop.
The same setup runs a client invoicing system on Monday and a family photo archive on Saturday. A landlord uses it for leases and maintenance. A teacher uses it for lesson materials and grading. A musician uses it for a tour page and a sample library. Nobody had to pick a plan or find a different product.
And because everything lives in one place, the parts start helping each other. The thing you built for work knows about the thing you built for yourself, when you want it to.
The infrastructure is genuinely free at the scale most people run at. Hosting, database, file storage, email, and login all sit inside free tiers far larger than a personal project will ever touch. Not a trial — the normal free plan for each service.
So the only thing you actually pay for is the thinking:
| What | Cost | Needed? |
|---|---|---|
| ChatGPT Go | $8/mo | Yes — this is the whole thing. Flat price, no meter. |
| OpenRouter credit | ~$1/mo | No. A cost-saver you add later, if ever. |
| Zed — free trial credit, then your own key | $0, then tokens | Instead of the above, if you want no subscription at all. |
If you are new, start here and stop reading. ChatGPT Go at $8 is the gentlest on-ramp: familiar interface, no per-message anxiety, and it includes Codex, which is the part that does the actual building. One setting worth getting right on day one:
OpenRouter is optional — skip it until it earns its place. It is not part of getting started and nothing breaks without it. Its only job is to make heavy months cheaper: you point the boring, repetitive work at a very cheap model instead of spending your ChatGPT allowance on it.
The moment to bother is when you start bumping into limits, or notice you are burning good tokens on drudgery — bulk edits, first drafts, file wrangling. Then add about a dollar of credit and wire in DeepSeek v4 Flash, which runs around $0.05 per million input tokens. A dollar covers more routine work than most people get through in a month. The worker model step below walks through it whenever you are ready — day one or month six, it does not matter.
Or pay no subscription at all. Zed is free and open source, and its two-week Pro trial hands you $20 of model credit — enough to build with before spending anything. After that, keep it free by pointing it at your own OpenRouter key and paying only for tokens, often cents a day. The trade is that you steer more and the wording on these pages assumes Claude Code or Codex. Good if $8 a month is the sticking point, or you want to try before you commit.
Going up instead is the other direction and most people never need it. Claude or ChatGPT Plus at $20 is smarter on genuinely hard problems; $100–$200 plans exist for people building heavily all day. Start at $8 and move only if you hit a wall.
A custom domain, if you want one, is about $10 a year. Prices checked August 2026.
Model recommendations checked 2 September 2026. This part of the stack ages fastest. If you are reading this after October 2026, assume something newer, better, or cheaper has landed — check openrouter.ai/models sorted by price before committing to any model named here. Nothing else in these instructions depends on which model you pick.
Several, and some are excellent. If one of them fits what you want, use it and skip all of this. If one of them is the better fit, that is the right call.
Here is who each one is really for.
Pick this if you have never built anything and want the easiest possible start. You type a sentence describing an app, and a working version appears while you watch. No setup, nothing to install.
The catch: the free version only lets you make about five changes a day, which a real project eats through quickly. Your app lives on their site, and you pay every month for as long as you want it to stay up.
Pick this if you want a website or web app quickly and do not care how it works underneath. It is fast, and it puts the result online for you straight away.
The catch: websites only — it cannot help with anything else on your computer. The free monthly allowance disappears fast once you are actually building something.
Pick this if you are curious about how things work and want to look under the hood. It is a full workshop in your browser: the AI builds, and you can read and change everything it wrote.
The catch: more knobs and panels than the others, which is either interesting or intimidating depending on the day. Still their computer, not yours.
Pick this if looks matter most. It makes the best-looking results of the bunch, and you can click on things and adjust the design by hand instead of describing every tweak.
The catch: it concentrates on the part people see, so anything behind the scenes is more of a struggle. It is also the priciest, and the price is per person.
Pick this if you want it to reach your own computer — your files, your folders, jobs running while you sleep — and you want to own what you build outright. It also stays cheap no matter how much you use it, and it can add new abilities to itself when you ask.
The catch: about two hours of setting up accounts before anything happens, and a stretch of trial and error after that. Nobody to call when it breaks; you and the AI chatbot work it out.
Prices checked August 2026 — worth confirming, they change often.
The short version: those four are a single tab and no setup, and they are the right answer for one app you want today. This one takes longer to start, then keeps going further — onto your own machine, into your own life, at a price that barely moves.
Anyone telling you this is effortless is selling something. It is free and optional, so here is the real shape of it.
The hard parts
The good parts
If the hard parts read as dealbreakers, one of the tools above is a better use of your afternoon — genuinely. If they read as a fair price, you will probably like this a lot.
Here is the uncomfortable truth about how most people use AI: they type into a box and read what comes back. That is it. It is genuinely useful, and it is also a rounding error next to what these systems can do.
The gap is not intelligence or credentials. It is whether you have ever given an AI real work — access to files, permission to act, a job that ends in something existing that did not exist before. Almost nobody has, because setting that up has been the hard part. That is the entire barrier this removes.
Do it once and you cross a line most AI users never cross. Not because you learned to code, but because you now know, from experience, what to hand off and what to keep, where these systems are brilliant and where they confidently get it wrong, and how to check their work. You cannot get that from reading about it.
How rare is that, really? One percent of eight billion people is eighty million — a crowd, not a club. Nobody keeps a real leaderboard, so treat this as an argument rather than a measurement. But the number of people who have actually run an AI agent with permission to touch their own systems is small, and the number who do it routinely is smaller. Building one working thing puts you in it.
And the real skill is stranger than it sounds. It is not learning to ask better questions, or memorising which model is best at what. It is learning to work with an AI on problems neither of you knows the answer to going in — where you cannot check the reply against something you already knew, because nobody in the conversation has the answer yet.
That is a genuinely different activity from asking a question. You form a hunch, the AI tries it, the result surprises one of you, and the next move comes from what you just learned together. You supply the judgement, the context, and the sense of when something smells wrong; it supplies the speed and the reach. Neither half gets there alone, and problems that would have stopped you cold get solved anyway.
That is the thing that compounds. It transfers to whatever tool comes next, because the lesson was never a product — it is a way of thinking alongside a capable machine instead of just talking to one.
Who this is actually for: people who want to own the thing they build, are curious enough to enjoy a puzzle, and are fine with two hours of admin before the good part. Not because it is hard — because it is fiddly, and that is a different tolerance.
Who should skip it: if you want one app by this afternoon, Lovable or Bolt will get you there faster and you will be happier.
Still interested? Start with the before-you-start homework — it gets the accounts out of the way first, at your own pace, and costs nothing to abandon halfway.
New to all this? Start at Before you start — it covers screenshots, choosing a credential manager, picking a coding agent (paid, or Zed free), and the six core services: GitHub, Supabase, Cloudflare, Google Cloud, Resend, and OpenRouter.
This is the one thing this page adds. Everything else is the same setup as normal — but before you start, the AI needs to be able to see and click inside a browser where you are already signed in.
You sign in. Never the AI. Log into Google, Cloudflare and Supabase yourself, in your own browser, with your own password and 2FA. Then hand over the already-signed-in tab. Do not type a password into a chat window, and do not ask the AI to create accounts for you.
Keep watching the screen. You still approve anything that spends money, accepts terms, or publishes something.
Keep the screenshot tool anyway. When browser control stalls — and it will — pasting a screenshot is how you get unstuck. Set it up so one key press puts the current window on your clipboard.
Windows: winget install ShareX.ShareX, then in Task settings → After capture tick Copy image to clipboard, untick Upload image to host, and give Capture active window a hotkey (Alt + PrintScreen is the default).
macOS: ⌃ ⇧ ⌘ 4 then Space copies a window straight to the clipboard, or install Shottr for annotation and history.
Do not let captures upload anywhere. You will be screenshotting API tokens and account pages. The normal page has the full walkthrough.
This is the only install you do yourself. Everything else is automatic. Node has to come first because the coding agent itself runs on it — Claude Code and the Codex CLI are both npm packages — so without Node there is no agent to hand the rest of the work to.
Download the LTS installer and run it — no terminal needed.
Already have Homebrew? brew install node does the same job.
Same LTS installer, or one command:
Open a new PowerShell window afterwards — PATH changes do not reach the window that made them.
Check it worked before moving on. Open a terminal and run:
Two version numbers means you are done. “Command not found” means the install did not finish, or you need a fresh terminal window.
Your agent needs terminal access. It has to run commands, not just write text. In Claude that means using Code mode rather than a normal chat; with Codex it means the CLI or a Codex task. If yours cannot run a command, nothing below will work — check that first.
Everything after this — Homebrew, git, the GitHub CLI, the Supabase CLI, wrangler, psql and the Bitwarden CLI — the agent installs for you, starting the slow ones in the background so they download while you work.
Two ways to get the agent that does the work. Option A is a flat monthly subscription. Option B costs nothing: Zed is free, its two-week Pro trial includes $20 of model credit, and after that it runs on your own OpenRouter key, billed per token. Pick one, then open it in a new, empty folder — the agent creates and clones the project for you.
One app, one flat bill, nothing to wire up. These pages were written and tested against these two, so the steps match what you see.
Claude Code works from an empty folder and handles setup, clone, and future development. Reads screenshots you paste in, and uses CLAUDE.md project directives.
Free to start; Pro $20/mo or Max $100/mo recommended.
Download Claude Desktop →No account? Sign up at claude.ai.
Codex — in the app’s sidebar or the Codex CLI — handles setup, cloning, and the build. Reads pasted screenshots, and uses AGENTS.md project directives.
Codex requires a paid plan — Go $8/mo, Plus $20/mo, or Pro $200/mo.
Download ChatGPT Desktop →Codex CLI: npm i -g @openai/codex — docs.
Zed is a free, open-source editor with an AI agent built in. Its two-week Pro trial includes $20 of model credit — enough to get the project standing up before you pay anyone anything.
Install, sign in, start the free trial from your account page, then set the agent’s model to Claude Sonnet 5 and open your empty folder. Rust rather than Electron, so it also runs in a fraction of the memory of a heavier editor.
After the trial: Pro is $10/mo, or stay free and run it on your own OpenRouter key — covered in Step 5.
Zed setup walkthrough →Screenshot-by-screenshot: install, trial, model, and the optional OpenRouter key.
Fair warning: slower and more hands-on, and these pages are worded for Claude Code and Codex — the steps still apply, you just translate the odd button name. Tell the agent to read AGENTS.md when a session starts.
Pick one path — you do not need both
Never installed any of these? The Before you start page walks through installing one and creating your accounts with its help.
aiprojects folder, open Code mode, and clone
2 min
This is where your project comes into existence. You make one folder to hold your AI projects; the agent creates your repository inside it and works from there.
aiprojects in your home folder — ~/aiprojects. It is a container, not the project itself, so anything you build later lives here too.~/aiprojects.~/aiprojects/ automatically.Naming. The agent proposes <name>-ai-app — your name or your project’s, so rahul-ai-app or bakery-ai-app — and waits for you to confirm or type a different one before creating anything. You end up with ~/aiprojects/<name>-ai-app.
No GitHub account yet? The agent runs gh auth login and waits while you sign in or sign up in the browser, then carries on.
Your own repo, not a copy of ours. The agent runs gh repo create <name>-ai-app --template rsonnad/alpacapps-infra --private --clone. That gives you a fresh repository with its own history and no remote pointing back at the template. Cloning the template directly would leave you committing against somebody else’s project.
Code mode starts by creating and cloning your repo — pure API work, no browser needed. The browser only comes out later, for the dashboard screens that have no API.
Follow along as Claude Code or Codex walks you through each step. Paste screenshots when asked — the agent verifies you’re on the right page and tells you exactly what to click.
Every API key the rest of this setup creates goes into Bitwarden. For the agent to use those keys — now and every session after — it needs to unlock the vault without a human typing the master password each time. Set this up once and it stays working.
The Bitwarden CLI arrives with the other tools when the agent runs scripts/install-prereqs.sh. Sign in once, then make unlocking durable:
Stores the master password in the macOS Keychain and unlocks from there.
First run asks for the password once and verifies it before saving. Add the export line to ~/.zshrc so every new shell has a session.
Same idea via DPAPI — the stored blob decrypts only for your Windows user on this machine.
Add the second line to your PowerShell profile ($PROFILE) to make it durable.
Not yet run on Windows. The script parses cleanly and its store/read logic is tested, but the DPAPI encryption and the icacls lock-down are Windows-only and unproven. If it fails, unlock by hand with $env:BW_SESSION = bw unlock --raw and tell us what broke.
Know what you are trading. Storing the master password means anything running as your user on this machine can unlock your vault. That is the price of letting an agent work unattended. Do not do it on a shared or work-managed computer, and keep an offline copy of the master password — Bitwarden cannot reset it for you.
Prefer to keep typing it? Skip this step and run export BW_SESSION=$(bw unlock --raw) yourself each session. Everything still works; you just do it by hand.
One macOS quirk: Keychain reads work in a normal terminal but usually fail from cron or a bare SSH session. If you later schedule something that needs a secret, give that job its own credential file rather than expecting the Keychain to answer.
Browser automation is slow, fragile, and gets challenged as bot traffic. So it is the last resort, not the method. Almost all of this setup has a real API and should never touch a browser at all.
| Service | How it gets done | Your part |
|---|---|---|
| GitHub | API — gh CLI | Approve one sign-in |
| Supabase | API — project, auth config, migrations | Paste one access token |
| Cloudflare | API — DNS, Pages, R2, D1, Workers | Create one token |
| Resend | API — domains, keys | Create first key |
| OpenRouter | API | Create key, add credit |
| Google Cloud | Browser — no API exists | Sign in, then watch and approve |
Google Cloud is the whole reason this page exists. Creating an External OAuth consent screen and a Web application client ID — what Supabase needs for Google Sign-In — can only be done in the console. The one programmatic route (gcloud iap oauth-brands) makes Internal brands inside a Workspace organisation and is aimed at Identity-Aware Proxy, so it does not cover this. Google Sign-In is core to the project, so the step cannot simply be skipped.
Where this is most likely to fail. The Google Cloud console watches for automation, and “a human signs in, then an agent clicks” is exactly the pattern detection systems now look for. You may get challenged. There is no way around it and you should not try — do that stretch by hand and let the AI pick up afterwards.
The console also changes its layout regularly, so an agent working from a remembered flow can confidently click the wrong thing. Watch it.
Cloudflare manages DNS, R2, D1, Pages, Workers, and related infrastructure. For initial setup, create a temporary API token broad enough for the agent to configure every selected service.
Intentional temporary exception: do not reduce this initial token to least privilege. It must be able to manage DNS, R2, D1, Pages, Workers, KV, Queues, Durable Objects, Tunnels, and account settings. If Cloudflare requires it, also create a temporary “Create Additional Tokens” token. Manually delete the temporary token(s) once setup is verified.
Core domain step: offer a low-cost .org or .us domain or a .com at its current price, then register the chosen domain with Cloudflare Registrar when possible (pause only for a required purchase confirmation). Configure public https://DOMAIN as the placeholder site and Google-authenticated https://in.DOMAIN as the intranet, with Cloudflare DNS, Pages, and HTTPS for both.
This is a core setup step. It needs a small prepaid OpenRouter balance and gives the main coding agent delegated models for implementation and code review.
Most tokens in a busy project go to grunt work — renaming a symbol across twelve files, filling in boilerplate, applying an edit you have already fully described. That work does not need a frontier model. So you split the job:
| Model | Input / M tokens | Output / M tokens | Role |
|---|---|---|---|
| Ox Alpha + DeepSeek v4 Flash | Check live | Check live | Delegated coding / review |
| GPT-5.6 Luna | $0.20 | $1.20 | Orchestrator |
| Claude Sonnet 5 | $2.00 | $10.00 | Orchestrator |
Model availability and pricing change. Check current input and output prices for both models at openrouter.ai/models before selecting the default.
Before you start: you need an OpenRouter account with a payment method and a small credit balance. That is covered on the Before you start page — complete it before wiring the models into the project.
1 · Store the key
Put the key in .env at the repo root, and confirm it can never be committed:
2 · Install the worker script
This is the bridge: it takes a task spec, sends it to DeepSeek through OpenRouter, and prints the reply. Both Claude Code and Codex can call it with a plain shell command.
Usage: scripts/deepseek.sh task.md src/a.js src/b.js — first argument is the spec, any files after it are attached as context. It reads OPENROUTER_API_KEY from .env, prints the reply on stdout and token usage on stderr. Override the model with DEEPSEEK_MODEL.
3 · Teach your orchestrator when to use it
The script does nothing on its own — your assistant has to know it exists and when delegating is worth it. Paste this into CLAUDE.md (Claude Code) or AGENTS.md (Codex). If you use both apps, paste it into both.
4 · Add Ox Alpha as a second delegated model
After OpenRouter is funded, paste this prompt into your main coding agent. It will compare the two current OpenRouter prices, make the lower-cost model the default for delegated coding and code review, and keep the other one as a fallback.
Why a script and not a subagent: Claude Code subagents only run Anthropic models, so there is no setting that points one at DeepSeek. A shell script is the seam that works from either app, and it keeps the worker in a box — it sees only the spec and the files you hand it, and it never writes to your repo.
5 · Codex only — run DeepSeek as the agent itself
If you chose ChatGPT Desktop / Codex, there is a second option: point Codex at OpenRouter directly and let DeepSeek drive a whole session. Add this to ~/.codex/config.toml:
Then start a session on the worker model when you want one, leaving your normal Luna sessions untouched:
Two things to expect: wire_api must be "responses" — current Codex has dropped "chat" — and Codex will warn that it has no metadata for the model and fall back to defaults. Both are normal. If your config sets service_tier, Codex drops it for non-OpenAI models and says so.
This mode has no supervisor. A full DeepSeek session edits your repo directly with nothing reviewing it. Use it on a scratch branch for bulk mechanical work, not on main, and read the diff before you merge. For everyday work the script in step 3 is the safer shape.
6 · Keep the bill boring
.env holds the key — never a committed file, never a screenshotDo not confuse this with swapping your main model. Pointing Claude Code at a third-party endpoint by overriding ANTHROPIC_BASE_URL replaces your orchestrator instead of giving it a worker — you lose the judgment that makes the split worth doing, and you are running your whole session through a proxy. That is a different thing, and it is not what this step sets up.
What to tell your assistant: “OpenRouter is funded, the key is in .env, and scripts/deepseek.sh is installed. Read the Worker Model Delegation rule and use it when a task qualifies.”
Your project will be live with:
CLAUDE.md file so Claude Code knows your project inside and outFrom there, just open Claude Code and tell it what you want to build. It handles all the code, commits, and deploys.
Full stack — spaces, tenants, devices, events, smart home, bookings. Everything you need to run a rental property or co-living space.
Core-only, fully pruned framework for a SaaS, personal tool, booking system, CRM, portfolio, or side project. No device drivers, smart-home code, mobile apps, kiosks, Home Assistant, or pollers unless you explicitly add them.
Both use the same template. Unless you explicitly choose Property Management or individual features, setup starts General AI Enablement as a core-only full prune; features can be added later.
Click checkboxes for cost estimate
This mainly affects your Claude Code plan and usage-based services.
67 edge functions, 11 workers, 2 native mobile apps — zero backend code
Already set up? New features get added to the template regularly. Run this prompt once a month to see what's new and adopt features you want:
Or browse the updates page directly to pick and choose.