Building BagaCam Better

I built a rabbit webcam in May 2025. It took a couple days of solid iteration. In January 2026, I rebuilt the exact same app in half a day. Same developer, same architecture. The models had improved, but the real acceleration came from workflow changes I'd figured out in between: spec-driven development, UI prototyping in Google AI Studio, and better patterns for directing agents.

The Setup

We rescued a rabbit last spring. Rabbits are social animals, and we were worried about leaving him alone when we traveled. I had a Raspberry Pi laying around, so I built a webcam that could stream to the cloud.

The May Build

I flashed Raspbian, connected over SSH, and pointed Claude Sonnet 3.7 to it. I had it install the Kinesis Video Streams library so the Pi could push video up to AWS. For the frontend, I bolted video playback onto an authentication template I'd already built with Cognito.

The whole thing worked. CloudFront deployment, authenticated access, video in the browser. But it was cobbled together. The UI wasn't polished, and some features wouldn't cooperate.

For the Pi to push video to AWS, it needs credentials to prove it has permission to write to Kinesis. I spent an hour trying to get IAM Role Anywhere working. This approach uses certificate-based credentials instead of an IAM user with a password string, which is more secure and the right way to do it. Claude kept trying different approaches, but we weren't getting anywhere. So I tabled it.

The January Rebuild

Eight months later, we had another trip coming up. It was time to get it working again.

Fresh Raspbian, SSH connection, but this time Opus 4.5 was on the other end. And my process had evolved.

I now use spec-driven development. I describe the app requirements, feed that into Google AI Studio to generate a React mockup, export it to GitHub, and point Claude Code to it. Claude gets a visual starting point instead of building UI from scratch. I also pointed it to the old repo for context: the architecture decisions, the Pi setup docs. Prior work became reference material.

My workflow has Claude decompose the implementation into discrete tasks, identify which can run concurrently, and spin up sub-agents to execute them in parallel. While one sub-agent wires up authentication, another builds the video player, and a third configures the Pi. It feels less like delegation and more like multiplication.

The Contrast

IAM Role Anywhere, the feature I'd tabled after an hour of going nowhere, got set up quickly this time. Same feature, same documentation, but the model just handled it better.

I added time-travel playback: go back an hour, three hours, up to 72 hours. The UI came together fast. The whole thing was functional by the end of that half-day session.

The result wasn't just faster to build. It was better. Cleaner UI, more features, more secure credentials. The May version worked. The January version felt polished.

What I Learned

Two things changed between builds: my workflow and the models.

The workflow matters. Spec-driven development gives Claude a target to hit. Parallel execution compresses sequential work. Prior documentation becomes leverage. These process improvements compound.

But the models themselves are dramatically more capable. The same task that had Claude spinning its wheels in May got solved quickly in January. The gap between "this should work" and "this actually works" shrank considerably.

If this trajectory holds, the ceiling on what I can build in a weekend keeps rising. Not incrementally, but dramatically. Every few months, projects that felt out of reach become afternoon experiments.

Now we can check on Rutabaga from anywhere.