Echo grows up and becomes Hey, Reachy

Justin Johnson — Mon, 15 Jun 2026 14:34:15 +0000

Echo started as a companion-platform idea: memory, proactive behaviors, a model picker, a lot of surface area. When I picked it back up I wanted the opposite. One thing, done well: talk to the robot, and the robot talks back out loud. So I rebuilt it, and renamed it to what you actually say to it. Hey, Reachy.

The loop

wake word  ->  listen (VAD)  ->  transcribe (STT)  ->  brain (LLM)  ->  speak (TTS)  ->  nod

You say a wake word, it wakes and listens, captures your sentence and stops on silence, transcribes it, sends it to a model, and plays the reply out of its own speaker with a small nod while it talks. After it answers it keeps listening for a few seconds, so a back-and-forth doesn't need a fresh wake every turn.

The wake word is keyless and on-device (openWakeWord), so the listening half needs no account and no API key. The brain, the speech-to-text, and the text-to-speech are all OpenAI-compatible endpoints, which means one gateway with one key can serve all three, and you can point the brain at whatever model you want. The brain sits behind one small interface, so swapping the engine never touches the app.

What the robot taught me

Three things only the hardware tells you:

Latency beats intelligence in a voice loop. A reply that lands in under a second feels alive. A smarter reply that takes three feels broken. I tuned for speed, not for the cleverest model, and the brain right now is gpt-oss-120b on Cerebras, which is what keeps it under that one-second bar.
Keep the speaker stream open. Early on, the first reply came from the robot and every reply after fell back to the laptop. Closing the audio stream after each utterance was releasing the robot's speaker. Hold it open across the conversation and it stays on the robot.
Stage directions are a trap. Ask a model to be expressive and it starts writing things like tilts head, which the text-to-speech then reads aloud. The fix is boring: tell it not to, and strip anything in asterisks before it speaks.

Motion is deliberately calm. A slow head-nod while speaking, antennas pinned because they're the part most likely to clip the robot's own face, and a level pose the rest of the time. Present, not fidgety.

Shipped

Hey, Reachy is live on Hugging Face and built on the same shared layer as Focus Guardian and DJ Reactor, so the voice stack (wake, listen, transcribe, speak) is reusable for whatever comes next. The interesting part starts now: wiring it to a real assistant so it has something worth saying.

Project home: runreachyrun.com · Repo: github.com/BioInfo/reachy · Space: huggingface.co/spaces/RyeCatcher/hey_reachy

I Built a Cyberpunk Story About Meta's AI Future Using AI as My Pair Programmer

Justin Johnson — Mon, 04 Aug 2025 11:00:00 +0000

The Technical Experiment

As developers, we often debate AI's impact on our profession in abstract terms. Will GitHub Copilot replace us? Is ChatGPT making juniors obsolete? Instead of another technical analysis, I tried something different: I used AI to write speculative fiction about our augmented future.

The result? "The Shadow of Superintelligence: Liberation or a Velvet Cage?" A story that explores Meta's vision of "personal superintelligence" through the eyes of Sarah, a marketer whose AR glasses give her superhuman abilities while her non-augmented colleagues mysteriously vanish.

The Tech Stack for Fiction

Writing Assistant: Claude (Anthropic)
Image Generation: Krea.ai

Story Structure: Three-act narrative with a twist ending
Research Integration: Real Reddit threads from developer communities
Version Control: Iterative prompting with context preservation

The Development Process

1. Initial Architecture

Story Structure {
  protagonist: "Sarah - developer turned marketer"
  setting: "2028 - Post personal AI revolution"
  conflict: "Augmentation vs human agency"
  technical_elements: [
    "Self-modifying algorithms",
    "Closed-source AI systems",
    "Neural-interface AR",
    "Blockchain data vaults"
  ]
}

2. Pair Programming with AI

Working with AI on creative projects is surprisingly similar to pair programming:

// Human provides the high-level design
const storyOutline = {
  theme: "surveillance as protection",
  tone: "cyberpunk thriller",
  technicalAccuracy: "plausible near-future"
};

// AI helps implement the details
const generateScene = (outline) => {
  return AI.expand(outline, {
    consistency: true,
    worldBuilding: true,
    characterDevelopment: true
  });
};

3. Debugging the Narrative

Just like code, stories need debugging. AI helped identify:

Plot holes (logic errors)
Inconsistent character behavior (state management issues)
Pacing problems (performance optimization)
Technical inaccuracies (type errors)

Technical Themes Explored

The Halting Problem Applied to Self-Improving AI

def ai_improvement_loop(model):
    while True:
        model = model.improve_self()
        # When does this stop? Can we predict the output?
        # Sarah glimpses this infinite loop in the story

Data Sovereignty in Neural Interfaces

The story explores a critical question: When AI needs access to your neural patterns to function, who owns that data? Meta's solution in the fiction: local blockchain encryption. But you're still locked into their ecosystem to access it.

The Vendor Lock-in of Human Augmentation

interface HumanAugmentation {
  provider: 'Meta' | 'Google' | 'Apple';
  capabilities: EnhancedAbility[];
  dependencies: SystemRequirement[];
  migrationPath: null; // <-- The real horror
}

Key Technical Insights from Writing Fiction

Recursive Improvement: Using AI to write about AI created an interesting feedback loop. The tool helped me explore its own implications.
Black Box Irony: I couldn't fully understand how my AI assistant was helping me write about... not understanding AI systems. Meta much?
The Documentation Problem: How do you document self-modifying code? The story's glitching AI scene came from this real technical challenge.
Security Through Obscurity: The twist reveals Meta's closed ecosystem as protection against worse actors. Technically dubious, narratively compelling.

Lessons for Developers

1. AI as a Creative Tool

Just as Copilot doesn't replace understanding code, AI doesn't replace creativity. It amplifies it. My process:

Human: High-level design and direction
AI: Implementation details and consistency
Human: Quality control and vision

2. New Skill Sets

The future might not be "AI replacing developers" but "developers who can orchestrate AI." This project taught me:

Prompt engineering as a design pattern
Context management across iterations
AI debugging (when output isn't what you expect)

3. Ethical Implementation

Writing this fiction highlighted real concerns:

How do we audit self-modifying systems?
What happens when human capability depends on proprietary AI?
Can security and transparency coexist in AI systems?

The Code Behind the Story

For fellow developers interested in the technical process, here's a simplified version of my workflow:

class StoryGenerator {
  constructor(ai, themes, style) {
    this.ai = ai;
    this.themes = themes;
    this.style = style;
    this.context = [];
  }

  async generateChapter(outline) {
    const prompt = this.buildPrompt(outline);
    const response = await this.ai.complete(prompt);

    // Maintain narrative consistency
    this.context.push({
      chapter: outline.chapter,
      keyEvents: this.extractEvents(response),
      characterState: this.trackCharacters(response)
    });

    return this.polish(response);
  }

  buildPrompt(outline) {
    return {
      role: "creative writing assistant",
      context: this.context,
      instruction: outline,
      style: this.style,
      constraints: ["technical accuracy", "narrative consistency"]
    };
  }
}

Try It Yourself

Want to experiment with AI-assisted creative work? Here's a starter template:

## Project: AI-Assisted Story About [Technical Topic]

### Setup
1. Choose your AI assistant (Claude, GPT-4, etc.)
2. Define your technical premise
3. Create character profiles with technical backgrounds
4. Outline 3-5 key scenes that explore technical concepts

### Prompting Strategy
- Start with world-building
- Maintain consistent technical rules
- Use AI for brainstorming and prose
- You control pacing and structure

### Debugging Process
- Read each scene for technical accuracy
- Check character consistency
- Verify the tech makes sense
- Ensure narrative flow

The Meta Question

Is using AI to write about AI dangers just techno-navel-gazing? Maybe. But it's also a unique way to explore these systems' implications. We debug code by running it. Perhaps we can debug our AI future by simulating it in fiction.

What's Next?

I'm considering open-sourcing a framework for AI-assisted fiction writing specifically for technical topics. Would anyone be interested in collaborating? The goal: make it easier for developers to explore technical concepts through narrative.

Read the full story: The Shadow of Superintelligence: Liberation or a Velvet Cage?

Discussion Questions

Have you used AI for creative projects? What was your experience?
What technical aspects of the story seem plausible/implausible for 2028?
How do you think AI pair programming will evolve beyond code?
What safeguards should exist for self-modifying AI systems?

Drop your thoughts below, or better yet, try writing your own AI-assisted fiction about a technical concept you're passionate about. Share your results!

About the Author: I'm a developer exploring the intersection of AI and creativity. This was my first fiction project, and I learned more about AI's implications by writing with it than from any technical paper.

DEV Community: Justin Johnson