# How to Vibe Code Your Own Yado (and Stop Paying for It)

> The calm place your AI lives

- Site: https://useyado.com
- Category: Developer Tools
- Platforms: iOS app
- Verdict: **Serious undertaking** (45/100 vibecodeable)
- Estimated effort: 4-6 weeks of part-time work

## Verdict

Build a personal subset with a React Native app wrapper and a lightweight VPS container manager, but expect weeks of intense debugging around terminal emulation and container orchestration.

Vibecoding a clone of Yado requires building across multiple disparate domains: a React Native mobile application, a Swift native terminal wrapper, server-side Docker container orchestration, and background worker state machines. While AI coding agents excel at writing boilerplate React Native components and Python/Node backend services, wiring up low-level VT100 terminal escape sequence handling in Swift, managing persistent container disks on a host, and keeping SSH or pseudo-terminal streams alive over WebSockets on mobile will involve significant debugging of networking edges and state synchronization.

### What you can't replicate

- The exact iOS app store distribution ecosystem and native polish
- The developer's personal workflow muscle memory

## What it does

An iOS app that lets you use Claude Code from your phone, without keeping your laptop on.

### Core features

- GitHub OAuth authentication and repository linking
- Dynamic cloud container provisioning and lifecycle management
- Claude Code API/subscription integration via PKCE webviews
- Dual interface with chat mode and native terminal emulation (VT100/Xterm)
- Background container task execution and push notifications via APNs
- Live web preview tunneling for active development environments
- MCP (Model Context Protocol) tool connector management
- Parallel agent management and differential view rendering

## The business

### Pricing

- Free Tier: $0/mo — Essential remote agent access.
- Pro Tier: $9.99/mo — Advanced developer capabilities.

Founded 2026.
Team size: 1.

## The hard parts

- Orchestrating secure, ephemeral Docker container environments with persistent disk state on a cloud provider
- Embedding a performant VT100/Xterm terminal interface inside a React Native iOS app with smooth touch scrolling and ANSI color rendering
- Managing background process lifecycles and reliable APNs push notification state machines when containers complete or require input
- Establishing secure tunneling for live web previews back to the mobile client

## How to vibe code Yado

### Prerequisites

- Mac + Xcode (Free): Required for compiling and running the native iOS React Native/Swift application and managing simulator builds.
- Node.js (Free): Required for running the React Native / Expo development environment and backend scripts.
- GitHub Account (Free): Required for repository integration, OAuth login, and cloning user projects into containers.

### Recommended AI tools

- Claude Code: The primary AI coding agent used to scaffold both the React Native mobile client and the container orchestration backend.
- Cursor: Provides an AI-native code editor interface for detailed multi-file edits across the mobile app and server codebase.

### Stack

- Frontend: React Native with Expo and TypeScript, utilizing native Swift wrappers for terminal emulation
- Backend: Node.js / Express orchestrator managing Docker container instances
- Database: Turso for lightweight relational state and session metadata
- Auth: better-auth configured with GitHub OAuth
- Payments: None (personal use clone)
- Other: Docker for isolated development environments, WebSockets for real-time terminal streaming

### Hosting

- Railway (Hosting the backend orchestrator and dynamic Docker container worker nodes): $10-20/mo
- Fly.io (Alternative full Docker VM host for persistent development container volumes): $5-15/mo

### Build guide

1. **Scaffold React Native Mobile Client with Expo** — Initialize the React Native mobile application using Expo and TypeScript, establishing navigation layouts for chat view, terminal view, and settings.

```
Create a new React Native app using Expo and TypeScript with file-based routing. Set up a bottom tab navigator with three screens: Chat, Terminal, and Settings. Install Lucide React Native for iconography and configure a clean dark-mode developer aesthetic inspired by coding environments. Ensure the layout supports both iPhone and iPad form factors smoothly.
```

2. **Implement GitHub OAuth and Session Authentication** — Set up authentication flows allowing users to sign in with GitHub and manage API keys or Claude subscription credentials.

```
Implement an authentication flow using better-auth configured with GitHub OAuth. Create an onboarding screen in the React Native app that prompts the user to sign in with GitHub, securely stores the resulting tokens using Expo SecureStore, and provides an alternative input form for custom Claude API keys or subscription tokens.
```

3. **Build Container Orchestration Backend API** — Construct a Node.js and Express backend service capable of spinning up isolated Docker containers per user upon repository selection.

```
Build a Node.js and Express backend service that communicates with the Docker socket or a container host provider (like Fly.io or Railway). Create endpoints to provision an isolated Ubuntu container pre-configured with Node.js, git, and Claude Code CLI when a user selects a GitHub repository. Implement persistent volume mapping so user workspaces survive container restarts.
```

4. **Establish WebSocket Terminal Streaming** — Build bidirectional WebSocket communication between the backend container pseudo-terminal (node-pty) and the mobile app terminal interface.

```
Implement a WebSocket server in the Node.js backend using `node-pty` to spawn an interactive shell session inside the user's provisioned Docker container. In the React Native client, build a terminal view wrapper using a native Swift module or React Native bridge that handles VT100 escape sequences, ANSI colors, touch scrolling, and forwards keyboard inputs over the WebSocket connection.
```

5. **Develop Chat Interface & Claude Code Integration** — Create a structured chat interface that interacts with the containerized Claude Code agent, rendering tool outputs, plans, and diff viewers.

```
Build a chat interface screen in the React Native app allowing users to send natural language prompts to Claude Code running inside their cloud container. Parse agent response events to display structured task plans, tool executions, file edits with diff viewers, and test results in real-time chat bubbles.
```

6. **Configure Live Web Previews and Background Notifications** — Set up reverse proxy routing for live preview URLs and integrate push notifications for background task completion.

```
Configure a reverse proxy on the backend orchestrator (using Nginx or Traefik) to dynamically route subdomain requests (e.g., [subdomain].yourdomain.com) to the correct user container preview port. Integrate Expo Notifications to trigger a push notification when a long-running background agent task finishes execution or requires user confirmation.
```

### Cost vs paying

**Starting costs (one-time):**

- Apple Developer Account (for real device deployment): $99/yr
- Total: $99 one-time

**Ongoing costs (monthly):**

- Backend & Container Hosting (Railway / Fly.io): $15/mo
- Claude API / Subscription Usage: Variable (BYOS)
- Total: ~$15/mo

- Paying for the SaaS instead: $9.99/mo (Pro)
- Build time: 40-60 hours
- AI tool credits: $20/mo (Claude Pro)
- Break-even: Never (built for personal learning and custom workflow control)

## Sources

- [Yado Official Website](https://useyado.com)
- [Apple App Store - Yado: Claude Code Mobile](https://apps.apple.com/us/app/yado-claude-code-mobile/id6742767073)