The Architecture Underneath the Screen
The problem
Look at how the app handles daily habits today. The quiz has a streak. Paw Pulse gives you a fresh insight about your pet once a day. The journal keeps a running timeline of what happened, day by day. On the surface these look like three unrelated features. Underneath, they're the same kind of thing wearing three different faces.
The quiz is a capability that watches for an answer, checks it against what it knows about you, and shows you something back. Paw Pulse is a capability that watches your pet's day, checks it against what it knows, and shows you something back. The journal does the same thing, just stretched across time instead of a single moment. Three different names, one underlying identity.
That identity gets lost the moment each one is built as its own island. Every one of them independently had to solve the same small problem: figuring out what "today" means for this particular pet or user, and whether they've already done their thing for the day. Nobody sat down and decided to solve that three times. The quiz needed to know if today's quiz was already answered, so that logic got written. Paw Pulse needed to know if today's insight was already generated, so a near-identical version of the same check got written again. Neither was wrong on its own. There just wasn't a shared place for "what counts as today for this pet" to live, so the same idea got reinvented instead of reused, once for every feature that happened to need it.
Chat shows a different shape of the same problem. If chat is really the same kind of thing as the quiz or Paw Pulse, a capability built on watching, understanding, and responding, then it should know as much about you and your pet as any of them do. Instead, what actually reaches it is your question and which pet you're asking about. Nothing about what you've talked about before, nothing about recent activity, nothing about this pet's history. Chat is treated as its own separate thing, answering with less than the shape it belongs to would normally give it.
The approach
The fix isn't a mandate to stop building features, and it isn't forcing every team to build a shared toolkit before shipping anything. It's simpler than that: a shift in the question asked before building starts. Instead of "what screen does this need," the question becomes "what kind of thing is this, architecturally, and has that kind of thing already been solved."
That's the heart of it. The quiz is a Context and AI capability. Paw Pulse is a Context and AI capability. And chat, looked at the same way, turns out to be one too. Once you name the shared identity instead of the surface difference, the same four things show up every time, just in a different order. Something happens: a quiz answer, a health update, a new day starting. That gets checked against what's already known about this pet or this user. Something makes sense of it, decides whether it's normal, worth flagging, or worth celebrating. And the result shows up wherever the user will actually see it, a card, a notification, a story, a chat reply. Sensors feed context, context feeds intelligence, intelligence drives a workflow, and the workflow decides how to surface itself. The specific words matter less than the shape. It repeats constantly, because it isn't really four different jobs, it's one job that every feature happens to be an instance of.
Seen this way, the duplication in daily tracking has less to do with quiz or Paw Pulse specifically, and everything to do with two instances of the same capability that don't know they're the same capability. Each one ends up asking "has this pet already done X today, and what happened around it" on its own, because there's nowhere shared to ask it once and let every feature that needs the answer read it. The same is true going the other direction: an event about a pet, a health update logged in one place, quietly becoming something another feature can find later, is a small but real example of features behaving like they belong to the same family instead of operating in isolation. That's what it looks like when the is-a relationship is actually respected instead of just being true in theory.
Where this fits at Hoomanely
None of this requires pausing feature work to build some grand unified system before anything else ships. What it requires is smaller: noticing the pattern the next time it shows up. If a new feature needs to know "has this pet done something today," that's the moment to recognize it as another instance of a capability we've already built several times, not a reason to write a fresh version of the same check inside that one feature.
There's a product reason to care about this too, not just a tidiness argument. Nir Eyal's Hook Model describes how habit-forming products work as a loop: a trigger prompts the user, an action follows, a reward comes back, and some form of investment makes the next loop more likely. A day starting, or a streak about to break, is the trigger. Opening the quiz or checking today's Paw Pulse insight is the action. Whatever comes back only feels like a real reward, worth returning for tomorrow, if it actually reflects something true and specific about this pet. A generic insight that could apply to any dog on any day doesn't earn a return visit the way a specific one does. And specificity is exactly what the is-a framing protects. When quiz, Paw Pulse, and chat are all recognized as the same kind of capability drawing from the same understanding of a pet, each one gets access to everything the others have learned, which is what makes the reward feel earned instead of scripted. Treat them as unrelated features instead, and every one of them is left guessing at its own smaller version of "specific enough to matter."
Key takeaways
Features that look different on the surface, a quiz, a daily insight, a running journal, a chat conversation, can still be the same kind of thing underneath. Naming that shared identity, rather than treating each one as its own island, is what stops the same small logic from getting reinvented every time a new daily habit feature comes along.
The reward side of the Hook Model depends on specificity, and specificity depends on context. A feature can only give back something that feels earned if it's actually drawing on what's known about this particular pet, not answering in isolation from everything else the app has learned.
The is-a relationship is a design stance, not a technical detail. Deciding that quiz, Paw Pulse, and chat are all instances of one capability, rather than three separate products, changes what gets built next and how much of it has to be built at all.
Author's note
The thing that stuck with me most while thinking this through wasn't the duplicated logic, it was chat. Of every feature in the app, chat is the one where the gap between what it could know and what it actually uses is most obvious to a user in the moment. It's a good reminder that the is-a relationship isn't just a tidy way to talk about architecture. It's a promise to the user that every part of the app that touches their pet is drawing from the same understanding, not answering from a smaller, disconnected version of it.
