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

> The language learning app that gets you speaking

- Site: https://speak.com
- Category: Education & Language Learning
- Platforms: iOS app, Android app, Web app
- Verdict: **Serious undertaking** (35/100 vibecodeable)
- Estimated effort: 6-8 weeks of part-time development

## Verdict

Build a basic desktop web wrapper with OpenAI voice APIs, but pay for Speak if you want production mobile audio handling and fine-tuned pronunciation models.

Replicating Speak requires mastering real-time bidirectional audio streaming over WebSockets, managing native microphone sessions across mobile operating systems, and implementing custom error-tracking pipelines. While an AI agent can quickly scaffold a React Native or Next.js skeleton, dialing in sub-second conversational latency and accurate phoneme scoring takes weeks of frustrating audio debugging.

### What you can't replicate

- Proprietary speech recognition models optimized for language learning errors
- Years of expert pedagogical curriculum design
- Direct OpenAI partnership and preferential infrastructure routing

## What it does

An AI-powered language learning application focusing on spoken fluency through a three-step method: Learn, Practice, and Apply with an interactive AI voice tutor.

### Core features

- Expert-crafted lesson delivery (audio/video patterns)
- High-repetition speaking drill interface
- Real-time voice streaming with AI tutor
- Pronunciation scoring and feedback analysis
- Personalized review path generation based on user errors
- Streak tracking, progress analytics, and daily reminders

## The business

### Pricing

- Speak Premium: $14.99/mo — Full access to core lesson library and real-time AI conversation practice.
- Speak Premium Plus: $29.99/mo — Advanced personalization including Made for You lessons and custom review paths.

### Funding

$162M raised.
- Seed (2016)
- Series A ($11M, Aug 2020)
- Series B ($27M, Nov 2022)
- Series C ($78M, Dec 2024)
Investors: Accel, OpenAI Startup Fund, Khosla Ventures, Y Combinator, Founders Fund, Lachy Groom, Justin Mateen

Founded 2016.
Team size: 51-100.

## The hard parts

- Sub-second real-time audio streaming infrastructure for natural conversation
- Granular phoneme and word-error-rate (WER) pronunciation scoring
- Stateful pedagogical error-mapping engine for dynamic micro-lesson creation
- Cross-platform audio session management on iOS and Android without clipping

## How to vibe code Speak

### Prerequisites

- Node.js (free): Required runtime for building the Expo mobile application and backend services.
- Expo (free): Cross-platform framework for compiling React Native code into native iOS and Android packages.
- GitHub (free): Source control and deployment pipeline integration.

### Recommended AI tools

- Claude Code: Best-in-class multi-file agent for scaffolding the full mobile and backend architecture.
- Cursor: Ideal IDE companion for refining UI components, animations, and audio wave visualizations.

### Stack

- Frontend: React Native with Expo router
- Backend: Node.js / Express with WebSocket support
- Database: Turso (SQLite at the edge)
- Auth: better-auth
- Payments: RevenueCat
- Other: OpenAI API (Realtime API & Whisper), Vercel AI SDK

### Hosting

- Fly.io (Hosting the Node.js backend server handling real-time audio WebSocket streams.): $5/mo
- Cloudflare (Hosting static API assets, lesson markdown content, and edge routing.): $0/mo

### Build guide

1. **Mobile App Scaffolding and Navigation Setup** — Initialize an Expo project with file-based routing and set up the core tab navigation for Lessons, Practice Drills, and AI Conversations.

```
Create a new Expo React Native project using TypeScript and Expo Router. Set up a bottom tab navigator with three main tabs: 'Lessons' (icon: book), 'Practice' (icon: mic), and 'Tutor' (icon: chatbubble). Configure a clean, modern dark/light mode theme using Tailwind styling via NativeWind. Establish folder structures for components, hooks, services, and constants. Ensure TypeScript strict mode is enabled throughout.
```

2. **Database Schema and Lesson Curriculum Models** — Design the SQLite schema via Turso to store language lessons, phrase patterns, drill sequences, and user progress history.

```
Set up a Turso SQLite database connection in a Node.js backend service. Write migration scripts to create tables for `languages`, `lessons`, `phrases`, `drills`, `user_progress`, and `user_errors`. Define schemas with foreign key relationships. Write REST endpoints to fetch lesson trees and record user completion states. Implement better-auth integration for secure user session management.
```

3. **Audio Recording and Pronunciation Capture** — Integrate native microphone recording utilities in React Native to capture user spoken phrases and handle permissions securely.

```
Implement audio recording functionality in the React Native app using `expo-av` or `react-native-audio-recorder-player`. Request microphone permissions gracefully on iOS and Android. Create a custom hook `useAudioRecorder` that records audio into temporary WAV files, manages state (recording, paused, stopped), and calculates waveform amplitude for visual feedback during speech drills.
```

4. **Speech-to-Text and Pronunciation Scoring Pipeline** — Connect backend ingestion to OpenAI's Whisper API and GPT-4o for phoneme analysis and constructive feedback generation.

```
Build a backend API endpoint that accepts multipart audio file uploads from the mobile app. Send the audio stream to the OpenAI Whisper API to get precise transcriptions with word timestamps. Pass the transcription and expected target phrase to GPT-4o with a strict JSON schema prompt to evaluate accuracy, naturalness, and specific phrasing errors. Return structured feedback including pronunciation score and correction hints to the client.
```

5. **Real-Time AI Tutor Voice Conversations** — Implement low-latency bidirectional WebSocket audio streaming using OpenAI's Realtime API for open-ended conversational practice.

```
Implement a real-time voice chat feature in the mobile app using WebSockets connected to OpenAI's Realtime API. Create an audio pipeline that captures microphone input PCM chunks, streams them over the WebSocket connection, and plays incoming audio chunks from the assistant seamlessly using native audio players. Add UI indicators for listening, speaking, and connection status, handling background interruptions and reconnection logic robustly.
```

6. **Personalized Error Review & Subscription Polish** — Aggregate user mistakes to generate custom corrective review lessons and wire up mobile billing.

```
Write a background job runner that queries the `user_errors` table weekly to synthesize weak spots into custom review lessons ('Made for You'). Integrate RevenueCat SDK into the React Native app to handle subscription paywalls, trial status checks, and access gating for Premium and Premium Plus tiers. Add polished haptic feedback, success animations, and sound effects for lesson completions.
```

### Cost vs paying

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

- Apple Developer Account (for native iOS testing/TestFlight): $99/yr
- Domain Registration: $12/yr
- Total: ~$111 one-time

**Ongoing costs (monthly):**

- Fly.io backend hosting: $5/mo
- OpenAI Realtime & Whisper API usage: ~$15-30/mo
- Total: ~$25-35/mo

- Paying for the SaaS instead: $14.99/mo
- Build time: 45-60 hours
- AI tool credits: $20 (Claude Pro) + ~$15 OpenAI API credits
- Break-even: 2 months

## Sources

- [Speak Official Website](https://speak.com)
- [SiliconANGLE: OpenAI backs $78M round for AI language learning startup Speak](https://siliconangle.com)
- [Practice Me: Speak App Review [2026]](https://practiceme.ai)