Context
Acorns of Wisdom
A team health check web app I built to teach myself AI-assisted prototyping. It started as a two-week recreation of a FordLabs tool I admired, and grew into a product teams at Atomic Object use today. Still in active development.
Try the app- Role
- Self-directed
- Timeline
- Prototype in 2 weeks, February 2026. Ongoing
- Stack
- Built with Claude Code, React, Firebase, Firestore, Vercel
Acorns was the first time I took a vibe-coded project all the way to a public deployment. I wanted to actually learn AI-assisted prototyping, and the way to learn it was to build something my team would actually use, not a toy app. So I chose to recreate Vibez, a team health check tool from my time at FordLabs, with my own branding and a few architecture decisions I wanted to think through end-to-end.
Vibez gave me a starting point I already trusted. With the design problem out of the way, I could spend the two weeks on the build workflow itself: how to scope work for an AI coding partner, when to push back on its suggestions, what kinds of tasks accelerate and which ones still need careful human input.
Problem
Reading about Claude Code wasn't going to teach me what I needed to learn. The vocabulary, the rhythm, the failure modes of AI-assisted building only show up when you do it yourself.
I picked a target with the right shape: small enough to ship in two weeks, real enough to expose the actual work, and inherited enough that I wouldn't have to design from scratch. Vibez fit. It was a tool I'd worked with, I knew the bones were good, and I had a clear sense of what I wanted to keep, change, and add.
Approach
The core of Acorns comes from Vibez: anonymous ratings, default health-check prompts, action items captured in the same view as the data, real-time anonymous chat alongside the dashboard. I kept those mechanics because they worked.
What's mine is the surface and the architecture. Code names (Mauve Penguin, Cobalt Narwhal) sit on top of the anonymity layer so the chat reads as a conversation rather than as a wall of unattributed text. The acorn rating scale, the squirrel mascot, and the visual identity are all new. Underneath, the architecture is deliberately minimal: single Firestore instance, passcode-based access rather than full auth, no integrations, no historical analytics, no exports.
The session works in three steps.
Step 1: Set the agenda. The eight built-in prompts cover the dimensions most teams care about: autonomy, equipment, quality, stress, vision, and others. Facilitators toggle them on or off, and write custom prompts alongside the defaults for things specific to their team.
Step 2: Rate anonymously. Each participant gets a random animal name on join. The identity is consistent within the session so the chat works, but nothing traces back to the individual. Each prompt is rated 1 to 5 on an acorn scale, with an optional anonymous comment.
Step 3: Review and act. Clicking any rating card expands it to show every vote and every comment. The anonymous chat runs alongside so participants can talk through specific ratings as their animal selves. Action items live in the same sidebar as the ratings, so the team leaves with follow-ups.
Decisions
Three calls I made that shaped what Acorns is and isn't.
Code names on top of inherited anonymity
Vibez gave participants anonymous identifiers that read as user codes. They worked, but the chat panel collapsed into a wall of nondescript labels that didn't help anyone follow a conversation. So I added a code-name layer: random animal names like Mauve Penguin and Cobalt Narwhal, persistent within a session.
The change is small and the effect is real. Participants can address each other in chat, references stay coherent ("Cobalt Narwhal, can you say more about that?"), and the surface gets a little warmth without compromising anonymity.
What I learned. Inherited mechanics still benefit from a critical pass. Anonymity worked in Vibez, but the expression of anonymity could be better, and that small change made the chat layer noticeably more usable.
Built for a small team, kept that way
Acorns runs on a single Firestore instance with passcode-based access rather than full authentication. There are no integrations, no historical analytics, no exports. Each of those is a real limit, and each is the right call for the actual use case.
The pull to expand a small tool toward something more general is real, especially when AI-assisted prototyping makes the next feature cheap. I held the scope on purpose. A health check tool for an eight-person team is a different product than one for a fifty-person org, and trying to be both makes both worse.
What I learned. AI tools dropped the cost of prototyping features to try and test ideas. The cost of deciding what belongs in a small product stayed exactly where it was. Knowing what to leave out is still the design work, regardless of what's cheap to prototype.
What changed later. Holding the scope tight is what let the prototype ship. When teams at Atomic Object picked it up, the real use case changed, and the scope grew with it: real sign-in, join codes and invites in place of a shared passcode, and tools for whoever runs the session.
Visual identity as part of the product
The squirrel mascot, the acorn rating scale, and the warm color palette weren't add-ons after the build. They were part of the product from the start. A team health check is a slightly uncomfortable thing to ask people to do, and a tool that signals "this is meant to be a little playful" lowers the activation cost. I drew the squirrel myself, instead of grabbing one from a stock library.
What I learned. Branding gets called soft when you're picking what to cut, but the soft choices are often the ones that determine whether anyone uses the thing. Treat the visual identity as a real design surface and ship with it from day one, not as polish at the end.
Outcome
The two-week prototype went straight into use on my team. Since then, Acorns has grown into a product that teams at Atomic Object use for their health checks, and I'm still building it.
The deeper outcome was the workflow fluency I came out with. I have a much sharper sense now of what's fast to build with AI assistance and what isn't, and that changes how I scope and validate ideas with engineering teams. A PM who has built something under constraint estimates differently than one who hasn't.
What's grown since the prototype:
- ○Sign-in, join codes and email invites, checked on the server, replacing the shared passcode.
- ○Facilitator tools: reveal results when the room is ready, sort and spread the cards, a shared timer, and a pop-out view for presenting.
- ○Run it again: repeat a health check and see trends against the last one, with prompt sets and follow-up seeds linked to the prompts.
- ○A friendlier room: anonymous chat likes, woodland code names, and more moments for the squirrel.
- ○Care work: an accessibility pass, security fixes with tests, and limits in the database rules.