My AI Built an Android App While I Slept

I went to bed with an idea. I woke up with an Android app.

Not a prototype. Not a proof of concept. Nine core source files, full build configuration, and all the plumbing to tie them together.

I didn't write a single line of code.

Here's what happened.

The Idea

I've been wearing Meta's Ray-Ban smart glasses since they launched. Recently, I found an open-source project called VisionClaw that connects them to AI through my personal assistant, OpenClaw. You can talk to it hands-free, show it what you're seeing through the glasses, and it can take action on your behalf through 50+ connected tools. The dream setup.

One catch: the app only exists for iOS. I use Android.

The options were pretty obvious: don't do it, spend several weeks learning to do it myself, or hire a freelance Android developer — $100/hour, minimum 10 hours for a port, $1,000+ for quality work, and weeks of back-and-forth on top.

So that evening, I sent my AI assistant a voice note:

"I found this thing that connects my glasses to AI. There's an iOS version but I need Android. Can you figure out what it would take to port it?"

Within minutes, it came back with a plan: the underlying platform supports both iOS and Android. The app itself is a straightforward port — translating from one programming language to another, with a clear reference implementation to follow.

Estimated cost: ~$15–$30 in AI API fees. I set a ceiling of $100 — less than a single hour of freelance developer time — with automatic budget monitoring and a two-hour timeout as safety nets.

"Go ahead and build it."

I went to sleep.

Three Agents, One Night

Here's where it gets interesting. My AI assistant didn't write the code itself — it orchestrated other AI agents to do the work.

First, a planning agent scaffolded the entire project. Seven minutes later: a complete Android project with source files, configuration, and permissions. The skeleton.

Second, a coding agent picked up that skeleton and started filling it in. File by file, translating the iOS codebase to native Android, working methodically through audio processing, camera integration, networking, and UI.

Third, a monitoring agent checked in every 15 minutes or so. It read a simple status file the coding agent maintained — current task, progress, blockers — and could intervene if things went sideways: suggest a different approach, restart with fresh context, or flag the issue for me.

Three agents. Each specialized. Each operating within clear boundaries. Working in concert while I slept.

I call this vibe working — a human sets the intent, an AI orchestrates other AIs to execute, and work happens in the background.

The Morning After

I checked my phone over coffee. The status file read:

Status: DONE
Progress: 9/9 files implemented

Nine core logic files. Audio capture with echo cancellation. Camera integration. Real-time AI streaming. A full interface with live transcription. All the networking, configuration, and lifecycle management to tie it together — plus resources and config, about a dozen files total.

The agents had even left TODO comments where hardware testing was needed, flagging the spots where a human with physical glasses would need to verify things. They knew what they couldn't test.

The Day-After Code Review

I pointed a different AI at the codebase and asked it to fix whatever was broken in the build.

The architecture was genuinely good. Clean separation of concerns, proper use of Kotlin conventions, thorough handling of the WebSocket protocol — audio, video, tool calls, transcription, interruptions, graceful disconnection. The code read like it was written by someone who understood both the Gemini Live API and Android conventions.

But it didn't compile.

Not because the logic was wrong — because the wiring was incomplete. The overnight agents couldn't run a build. They generated code in isolation, file by file, and the seams showed. A class name collided with an Android system class. A dependency was missing from the build file. Launcher icons were never created. Placeholder credentials produced a wall of errors.

Seven distinct issues. All of them integration problems — the kind that surface the moment you hit "build" and vanish in minutes once you can see the error output. None of them were design problems.

That distinction matters. The agents produced a codebase where the hard decisions were already made correctly: the audio pipeline architecture, the protocol handling, the state management approach. What they missed was mechanical — build configuration, resource files, namespace collisions. Things a single compile cycle would have caught.

The overnight run was a first draft that understood the assignment. The morning fix-up was integration cleanup.

That ratio — architecture right, plumbing rough — is what AI-generated code looks like right now. And it's a ratio that favors the human reviewer enormously, because it's far easier to fix wiring than to fix thinking.

The Math

That's not a marginal improvement. That's a different category entirely.

Now — before this sounds like a fairy tale — let me be clear about why it worked.

The problem was well-defined: a direct port with a reference implementation to follow. The context was clean. The task decomposed naturally into agent-sized pieces. This wasn't novel architecture or ambiguous business logic — it was translation work, which is exactly what AI agents excel at today.

Messier problems take longer. Some problems still need human judgment throughout. My AI agents are force multipliers, not replacements — they handle the 80% that's translation, scaffolding, and implementation. The 20% that requires decisions, architecture, and strategy? That's still mine.

But even with those caveats, the throughput shift is real.

Why This Matters Beyond My App

A year ago, "vibe coding" was a meme — Andrej Karpathy's shorthand for working with LLMs on code without fully understanding every line. The critics were right to be skeptical. The models weren't ready. The results were inconsistent.

That's changed. The models are dramatically better. The orchestration patterns exist. And critically, the same approach extends beyond code — research, analysis, writing, operations. Once you learn to decompose a problem into agent-sized tasks with clear context, the domain almost doesn't matter.

The bottleneck isn't AI capability anymore. The bottleneck is learning to work this way.

That shift — from doing the work to directing the work — is what I mean by vibe working. It's not about replacing expertise. It's about applying yours differently: as a director of intelligent agents rather than a solo executor.

The Meta Layer

There's something recursive about this particular project. I built an app that connects AI glasses to an AI assistant, using AI agents that coordinated overnight. Then I asked an AI to draft this blog post about it. Then I edited that draft with another AI, pulling from the original conversation logs to fact-check the numbers.

AI building software. AI writing about it. AI editing the writing. Each layer using the artifacts of the last.

We're early. But the direction is unmistakable.

This builds on my earlier posts about vibe working and context sculpting. The original iOS project is on GitHub.