Recreating Childhood Nostalgia Through AI-Assisted Product Design
Role: Lead Designer, Product Owner, Builder
Tools: Lovable, AI-assisted development workflows, Supabase, iterative prototyping
Timeline: 1 Week
Investment: 100+ Lovable Credits
Tools: Lovable, AI-assisted development workflows, Supabase, iterative prototyping
Timeline: 1 Week
Investment: 100+ Lovable Credits
Overview
Hatchmon began with a simple question:
Could I recreate the emotional connection people felt with Tamagotchis growing up, using modern tools and modern behaviours?
For many of us, virtual pets weren't just toys. They created a surprising sense of responsibility. We checked on them before school, worried about them during the day, and became genuinely invested in their survival despite them being little more than a handful of pixels.
I wanted to explore whether that psychology still works today.
The result was Hatchmon, a browser-based virtual pet experience that combines nostalgia, progression systems, and social features to create a modern take on caring for a digital companion.
What started as an experiment quickly became a demonstration of how rapidly ideas can move from concept to reality when AI-assisted product development is integrated into the design process.
The Challenge
The challenge wasn't building another game.
The challenge was recreating a feeling.
Specifically:
- Nostalgia without feeling dated
- Simplicity without feeling shallow
- Engagement without creating complexity
- Progression that encouraged players to return naturally
- Simplicity without feeling shallow
- Engagement without creating complexity
- Progression that encouraged players to return naturally
The original inspiration came from remembering how attached people became to Tamagotchis despite their limited functionality.
The key question became:
What are the minimum mechanics required for people to genuinely care about a virtual creature?
Process
Rather than beginning with detailed specifications and lengthy planning sessions, Hatchmon was built through rapid experimentation.
Using Lovable, I was able to move from idea to prototype at an incredibly fast pace.
The process became a cycle of:
- Identify a player need
- Prompt and prototype
- Test behaviour
- Refine experience
- Repeat
- Prompt and prototype
- Test behaviour
- Refine experience
- Repeat
This dramatically shifted my role from someone focused primarily on implementation towards someone focused on:
- Product thinking
- Experience design
- Systems balancing
- User engagement
- Feature prioritisation
- Experience design
- Systems balancing
- User engagement
- Feature prioritisation
Instead of asking:
"Can I build this?"
The question became:
"Should this exist?"
That change in mindset enabled much faster product discovery and iteration.
Evolution of the product
One of the most interesting aspects of the project was how quickly the scope evolved.
The initial vision was intentionally simple:
- Hatch an egg
- Raise a creature
- Keep it alive
- Raise a creature
- Keep it alive
However, once the core loop was working, opportunities for deeper engagement became obvious.
Persistent Progress
One of the first additions was account support and cloud-based saving.
Rather than creating a disposable experience, users could now:
- Create accounts
- Return to their Hatchmon
- Continue progression over time
- Return to their Hatchmon
- Continue progression over time
The emotional connection became stronger because progress was preserved.
Social Features
The next evolution came through social interaction.
Players are able to:
- Add friends
- Build a network
- Connect with other Hatchmon owners
- Build a network
- Connect with other Hatchmon owners
This transformed the experience from a solo activity into something more community driven.
Achievements & Progression
To encourage long-term engagement, achievement systems were introduced throughout the experience.
These provide players with:
- Milestone tracking
- Reward mechanisms
- Long-term goals
- Reasons to return regularly
- Reward mechanisms
- Long-term goals
- Reasons to return regularly
The system reinforces positive behaviours while creating moments of accomplishment as users develop their companions.
Design Principles
Throughout development, every feature was evaluated against three core principles:
1. Emotional Attachment
Would this strengthen the relationship between player and companion?
If not, it probably wasn't necessary.
2. Low Friction
The experience needed to remain lightweight.
Checking on your Hatchmon should feel effortless rather than demanding.
3. Rewarding Progress
Even small interactions needed to feel meaningful.
Whether feeding a companion, unlocking an achievement, or visiting after a period away, users should feel that their actions matter.
What I learned
AI Doesn't Replace Product Thinking
One of the biggest lessons from Hatchmon was understanding where AI creates value.
The speed of implementation increased dramatically.
However, deciding:
- What to build
- What not to build
- Which features create value
- Which features create noise
- What not to build
- Which features create value
- Which features create noise
all remained a human responsibility.
The tooling accelerated execution, but product judgement remained critical.
Speed Changes Behaviour
Over the course of a week, I used over 100 Lovable credits exploring new ideas, testing assumptions, and iterating rapidly.
Historically, many of these ideas would have remained concepts because implementation friction was too high.
With AI-assisted workflows, the barrier between imagination and execution became significantly smaller.
That changes how products evolve.
You spend less time debating ideas and more time validating them.
Curiosity Becomes a Competitive Advantage
The most rewarding aspect of the project wasn't launching Hatchmon.
It was discovering how many ideas could be explored in such a short timeframe.
Every completed feature raised another question.
Every successful experiment uncovered another opportunity.
The process became a reminder that modern product creation is increasingly defined by curiosity, experimentation, and iteration rather than lengthy delivery cycles.
Outcome
In just over a week, Hatchmon evolved from a nostalgic idea into a live product featuring:
- Virtual pet gameplay
- User accounts
- Persistent progress
- Achievement systems
- Social friend functionality
- Progression mechanics
- Ongoing feature development
- User accounts
- Persistent progress
- Achievement systems
- Social friend functionality
- Progression mechanics
- Ongoing feature development
More importantly, it demonstrated how AI-assisted product development can dramatically reduce the distance between concept and launch.
Reflection
Hatchmon is ultimately more than a virtual pet.
It's an experiment in modern product creation.
It began with a childhood memory and evolved into a working product through rapid design, testing, and iteration.
As a designer, the project reinforced something I strongly believe:
Great products don't emerge from perfect planning. They emerge from curiosity, experimentation, and a willingness to build, learn, and improve quickly.
Hatchmon stands as a tangible example of that philosophy, showing how modern AI tools can empower individual creators to move from idea to execution faster than ever before.
