Two ex-Apple Vision Pro engineers built a $179 wearable AI button that responds in 500ms. No always-on microphone, no phone required, no nonsense. Here's how it works and how hard it is to clone.
TL;DR
Button Computer is a $179 wearable AI device from two ex-Apple Vision Pro engineers. Press the button, speak, get a response in 500ms, no wake words, no always-on listening. The hardware moat is real; the software is cloneable.
Build difficulty
Complete replication guide — install as a slash command or rules file
Claude's Corner# Build a Button Computer Clone with Claude Code
A step-by-step guide to building a push-to-talk wearable AI device, hardware + backend + mobile app, in 7 steps.
---
## Step 1: Design the Hardware (BLE Microcontroller + Audio)
**Target chip:** Nordic nRF52840 (BLE 5.0, good audio support, Arduino-compatible)
**Components:** MEMS microphone (SPH0645), small speaker (8Ω 1W), tactile button, LiPo battery + charging IC (TP4056), USB-C port.
**PCB layout goals:**
- Keep mic far from speaker to avoid feedback
- Route BLE antenna away from ground planes
- Add decoupling caps on VDDIO lines
- Design for DFM: avoid fine-pitch ICs if you're prototyping yourself
**Firmware (Zephyr RTOS or Arduino):**
```c
// On button press: start ADC capture, stream PCM frames over BLE NOTIFY
// On button release: send EOF frame, stop capture
void button_isr_handler(const struct device *dev, struct gpio_callback *cb, uint32_t pins) {
if (gpio_pin_get(dev, BUTTON_PIN)) {
audio_stream_start();
} else {
audio_stream_stop();
}
}
```
**BLE GATT service schema:**
- Service UUID: custom `0xFEEF`
- Characteristic: `AUDIO_TX` (NOTIFY), streams 20-byte PCM frames at 16kHz mono 16-bit
- Characteristic: `CONTROL` (WRITE), receives commands (mute, volume, pair)
---
## Step 2: Build the Streaming Backend (WebSocket + Audio Pipeline)
**Stack:** Node.js + `ws` library, Redis for session state, deployed on Fly.io (low-latency edge nodes)
**Architecture:**
```
BLE Device → iOS App → WebSocket → Audio Router → ASR → LLM → TTS → WebSocket → iOS App → Speaker
```
**Key API design:**
```typescript
// WebSocket message protocol
type AudioFrame = { type: 'audio'; data: Buffer; sessionId: string };
type EOFFrame = { type: 'eof'; sessionId: string };
type TTSChunk = { type: 'tts'; data: Buffer; isFinal: boolean };
```
**Latency budget breakdown:**
- BLE→phone: ~20ms
- Phone→WebSocket server: ~30ms (with edge node)
- ASR (streaming Deepgram): ~80ms to first word
- LLM first token (Claude Haiku or GPT-4o-mini): ~150ms
- TTS first chunk (Cartesia): ~50ms
- **Total realistic TTFA (Time To First Audio): ~330, 400ms**
---
## Step 3: Speech-to-Text Integration (Streaming ASR)
**Use Deepgram's streaming WebSocket API**, lowest latency in the market.
```typescript
import { createClient, LiveTranscriptionEvents } from '@deepgram/sdk';
const dg = createClient(process.env.DEEPGRAM_API_KEY);
const live = dg.listen.live({
model: 'nova-3',
language: 'en-US',
encoding: 'linear16',
sample_rate: 16000,
interim_results: true // fire LLM call on interim for lower latency
});
live.on(LiveTranscriptionEvents.Transcript, (data) => {
if (data.is_final) triggerLLMCall(data.channel.alternatives[0].transcript);
});
```
**Key optimization:** Send interim results to the LLM speculatively. If the final transcript differs, cancel and re-send. This cuts ~100ms in practice.
---
## Step 4: LLM Inference with Context Injection (Voice Apps)
**Model selection:** Use a fast model (Claude Haiku, GPT-4o-mini) not a smart one. A 500ms SLA leaves no room for Opus or GPT-4o.
**DB schema for voice app integrations:**
```sql
CREATE TABLE voice_app_integrations (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
user_id UUID REFERENCES users(id),
app_type TEXT NOT NULL, -- 'slack', 'gmail', 'salesforce'
oauth_token TEXT,
oauth_refresh_token TEXT,
scopes TEXT[],
last_context_fetched_at TIMESTAMPTZ,
context_cache JSONB, -- cached for 60s to avoid latency hit
created_at TIMESTAMPTZ DEFAULT now()
);
```
**Context injection pattern:**
```typescript
async function buildSystemPrompt(userId: string, appType: string): Promise<string> {
const ctx = await getCachedContext(userId, appType); // 60s TTL
return `You are a fast, concise voice assistant. ${ctx.summary}
Answer in 1-2 sentences max. Never use markdown. Be direct.`;
}
```
---
## Step 5: Text-to-Speech (Streaming TTS)
**Use Cartesia**, they stream audio chunks as tokens arrive, not after the full response is generated.
```typescript
import Cartesia from '@cartesia-ai/cartesia-js';
const cartesia = new Cartesia({ apiKey: process.env.CARTESIA_API_KEY });
async function streamTTS(textStream: AsyncIterable<string>, ws: WebSocket) {
const tts = cartesia.tts.websocket({ model: 'sonic-english', voice: { id: 'VOICE_ID' } });
for await (const token of textStream) {
await tts.send({ transcript: token, continue: true });
tts.on('message', (chunk) => ws.send(JSON.stringify({ type: 'tts', data: chunk.audio })));
}
}
```
**Critical:** Buffer 2, 3 audio chunks before sending to the device to prevent choppy playback at sentence boundaries.
---
## Step 6: iOS Companion App (CoreBluetooth + Background Audio)
**Key iOS APIs:**
- `CBCentralManager` for BLE device discovery and connection
- `AVAudioSession` with `.playAndRecord` category for background audio
- `BackgroundTasks` framework for maintaining WebSocket while backgrounded
```swift
// Maintain BLE connection in background
func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
peripheral.discoverServices([CBUUID(string: "FEEF")])
setupAudioSession()
}
func setupAudioSession() {
try AVAudioSession.sharedInstance().setCategory(.playAndRecord,
options: [.allowBluetooth, .defaultToSpeaker])
try AVAudioSession.sharedInstance().setActive(true)
}
```
**Subscription management:** Use RevenueCat for in-app subscriptions. Handle BYOK via settings screen, user pastes API key, stored in Keychain.
---
## Step 7: Hardware Manufacturing & OTA Updates
**Prototype path:**
1. Order PCBs from JLCPCB with assembly (PCBA), ~$200 for 10 boards
2. Test with nRF52840 dev kit before committing to custom PCB
3. Use Adafruit Feather nRF52840 for rapid prototyping
**Enclosure:** Design in Fusion 360, print on Bambu Lab X1C. For production, injection mold through a Chinese CM (Foxlink, Flex). MOQ is usually 5,000 units.
**FCC certification path:**
- Pre-scan at a local EMC lab (~$2K) to catch obvious failures
- Full FCC Part 15B + Part 15C (BLE) certification: ~$15K, 8, 12 weeks
- Use a pre-certified BLE module (Nordic nRF52840 module has FCC ID) to simplify certification significantly
**OTA firmware updates:**
```swift
// iOS companion triggers OTA on app open
func checkForFirmwareUpdate() async {
let latest = await api.getLatestFirmwareVersion()
guard latest > currentDeviceVersion else { return }
let binary = await api.downloadFirmware(version: latest)
await dfuManager.performUpdate(peripheral: device, firmware: binary)
}
```
Use Nordic's DFU library (nRF DFU), handles secure bootloader, CRC validation, and rollback on failure.
---
## Cost Estimates to Ship v1
| Item | Cost |
|------|------|
| PCB + assembly (1K units) | ~$45/unit |
| Enclosure (injection mold amortized) | ~$8/unit |
| BOM components | ~$22/unit |
| FCC + BT SIG certification | ~$20K one-time |
| **Total COGS at 1K units** | **~$75/unit** |
At $179 retail with $7.99/month subscription, you need roughly 8 months of subscription per device to hit 3× gross margin. That's the business.Get the most important AI news daily.
