Baby Monitor Timmy started with a simple idea: a baby monitor that respects privacy at home. No cloud recordings, no unnecessary data paths out of the nursery. What many people do not see: I build Timmy as a solo project in Zurich, and GitHub Copilot is my very fast pair programmer.
The Human-AI Workflow
The split is clear: I define features, set priorities, and make architecture decisions. Copilot helps with implementation: writing code, adding tests, narrowing down bugs, and preparing release steps.
A typical sprint looks roughly like this for me:
- Feature description: I describe what the feature should do, including edge cases and constraints.
- Implementation: Copilot suggests code and follows the project's existing conventions.
- Testing: Automated end-to-end tests run on two emulators and check the real baby/parent connection.
- Distribution: When tests pass, Android and iOS builds are prepared for the right store and testing tracks.
This cycle repeats for features and bugfixes. I do not write every line myself, but I decide what gets built, why it gets built, and whether a suggestion fits Timmy.
From Concept to WebRTC
The central technical task was clear from the start: real-time audio and video between two phones. WebRTC was the obvious choice, but integrating it with Flutter is not trivial: ICE candidates, SDP negotiation, TURN fallback, and DataChannels need to work together in the right order.
Copilot helped me pull those pieces together step by step: set up the peer connection, keep the critical order correct (DataChannel before offer, onTrack before setRemoteDescription), and put signaling on Firebase Firestore. Each piece had to run on two emulators before I moved on.
Secure Pairing with ECDH
One of the most critical features was the secure pairing system. Two devices need to establish mutual trust without relying on a central server to vouch for their identity. The solution: an ECDH P-256 key exchange over Firebase, combined with a visual verification number (SAS) that detects man-in-the-middle attacks.
Copilot helped implement the cryptographic chain: key generation, public key exchange, shared secret derivation, SAS computation, and AES-256-GCM encryption for all later signaling data. I do not send the pairing key to the backend; only its SHA-256 hash is used as a Firestore document identifier.
Security Audit: Finding and Fixing Vulnerabilities
AI-assisted development is not only faster typing for me. It also helps with systematic bug hunting. In a focused security audit sprint, Copilot analyzed the codebase and found six issues I needed to fix:
- Missing input validation on signaling data
- Potential race conditions in the ICE candidate handling
- Stale session data that wasn't being cleaned up properly
- Firestore security rules that were too permissive
- Missing certificate pinning considerations
- Insufficient error handling in the TURN credential flow
All six were fixed in the same sprint. This is where Copilot is strong: reading many files, comparing patterns, and marking places I need to inspect more closely.
Iterative Sprints: How the App Evolved
Timmy grew through fast but clearly bounded sprints. Some milestones:
- v1.8: Complete pairing redesign — 4-char code + ECDH P-256 over Firebase replaced the old direct-key approach.
- v1.10: Security hardening sprint — the six-vulnerability audit and fix cycle.
- v1.11: Dark mode across all screens, plus the homepage and blog you're reading right now.
- v1.12: Major parent screen overhaul, night vision mode, and motion detection via camera frame analysis.
Every sprint follows the same basic pattern: describe the goal, review suggestions, test automatically, then ship to testers.
E2E Testing Across Devices
You cannot test a baby monitor properly on one device. I need one baby device and one parent device. The project started with two Android emulators running simultaneously and now complements that loop with local iOS simulator and real-device checks. The automated Android test script still:
- Installs the app on both emulators
- Navigates through pairing on both devices
- Verifies that audio and video connections are established
- Tests push-to-talk, camera control, and other features
Since both emulators share the same IP address (10.0.2.15), a direct peer-to-peer connection via STUN is impossible. Every test run has to go through the Cloudflare TURN relay. That is annoying, but useful: the most complicated connection path is tested every time.
What I Learned
Building a complete app with an AI pair programmer taught me a few things:
- Architecture matters more than ever. Clear conventions and a well-documented codebase help the AI suggest consistent code. Ambiguity gets expensive quickly.
- Testing is non-negotiable. AI-generated code needs the same rigorous testing as human-written code. Automated E2E tests caught issues that would have been easy to miss manually.
- The human stays in the loop. Every architectural decision, every security trade-off, and every product boundary stays with me. AI speeds up implementation, but it does not replace judgment.
- Speed enables quality. Because features ship in hours instead of days, there are more iterations left for polish and bug fixing. Fast does not automatically mean good.
Looking Ahead
Baby Monitor Timmy keeps evolving. The iOS release is close; after that come additional sensor features and ongoing security hardening. The workflow stays similar: I set direction and boundaries, Copilot helps implement and check quickly.
The security-relevant building blocks now live under clear boundaries in the public baby-monitor-timmy-core repository. That is also where the architecture decisions around pairing, signaling, and backend interfaces are documented.