I'll be honest, I clicked into this one ready to be annoyed. Every other week there's a new "AI dev tool" that turns out to be a chat window with a system prompt and a GitHub star-begging README. I've burned enough evenings on those to be suspicious by default.
But a friend pointed me at ohmyaistaffs last week — a self-hosted, single-binary thing that claims to take a plain-language request and hand you back a compiled, tested, running app, not just a pile of markdown or a scaffold with 40 TODOs in it. No account, no license key, free. That combination of claims (self-hosted + no login + "it actually compiles") was specific enough that I figured it was worth ten minutes to check if it was real.
Getting it running
No signup flow, no dashboard to click through. Just:
curl -fsSL https://ohmyaistaffs.io/install.sh | bash
That's it — it drops a single Go binary on your machine and serves its own UI locally. No Docker Compose file, no Postgres you have to spin up first, no "create an account to get your API key." If you already have Claude Code CLI installed and logged in, it'll piggyback on that session instead of asking you for a key at all. If not, it supports basically everything else too — Anthropic, OpenAI, Azure OpenAI, Bedrock, Vertex, Gemini, OpenRouter, Groq, DeepSeek, Mistral, xAI, or fully local via Ollama/LM Studio. Bring your own model, swap it later, nothing's locked to one vendor.
What actually happens when you give it a request
This is the part I expected to be underwhelming. It wasn't quite.
You type one sentence — I tried something boring on purpose, a small internal tool for tracking equipment loans — and instead of immediately vomiting out code, it comes back with clarifying questions first. Who can mark something as returned? Does overdue matter? Is there more than one location? It's a small thing, but it's the difference between "the model guessed and baked a wrong assumption into 12 files" and actually catching that stuff before code exists.
After that it works in three visible stages, and you can stop at any of them:
- clarify — just the spec/requirements docs
- design — spec + actual HTML screens, built from a shared design-token set (13 named color roles, one type scale, one spacing scale) so screens don't end up looking like five different apps mashed together
- build — the real thing: data model, API wiring, tests, seed data
The UI represents this as agents sitting at desks on a little office floor with a task board (queued / working / in review / done), which sounds gimmicky written out like this, but in practice it's just a legible way to see which of the three roles — analyst, designer, engineer — is doing what, and there's a clear "waiting on you" indicator when an agent is stuck on a decision instead of silently guessing.
The part that actually got me
Anyone can promise "AI writes your app." The thing that made me trust this more than the average tool: the generated backend is plain Go stdlib, and the pipeline runs go build, go vet, gofmt, and go test against what it produces before calling a task done. It's not "trust me, the LLM said it works." There's a compiler in the loop. Storage is JSON files with atomic rename writes rather than some hidden managed DB you now depend on, and CRUD operations do real state-transition validation instead of the classic AI-demo move of stubbing everything as a 501.
Two other details worth mentioning if you're evaluating this seriously rather than just kicking the tires:
- You can point it at an existing repo instead of starting from scratch. It lazily indexes the folder (keyword + link index, not a full copy), figures out how to run it —
package.jsonscripts,go.mod, a Makefile target, whatever — and gives you a live preview against your actual codebase. - Cost tracking is per-agent and per-call, attributed the moment the provider reports token usage, not estimated after the fact. If you're paying per token across three agents that all get to call out to a model, that matters more than it sounds like it should.
What it's not
It's not magic, and it's not going to replace someone thinking about your actual product. It's also clearly early — there's dormant licensing/billing scaffolding in the codebase for a future paid tier that isn't wired up to anything yet, which tells you it's a project still figuring out its shape, not a finished commercial product with a pricing page. If you need enterprise SSO or a hosted managed version today, this isn't that — it's a binary you run yourself.
But for the specific job of "turn a vague internal request into a working prototype I can poke at before committing to a real design doc," it did what it said, and the fact that the output has to survive go build before it's called done is the reason I'd actually reach for this again instead of just letting it collect dust next to the other tools I tried once.
If you want to try it yourself, it's still just:
curl -fsSL https://ohmyaistaffs.io/install.sh | bash
Curious if anyone else has run it against something bigger than a toy internal tool — drop a comment if you have, I'd like to know where it breaks.
Top comments (0)