{Submit} Tiny Tamagotchi MVP with Spec-Driven Development

Short Course Q&A Spec-Driven Development with Coding Agents
,
1

Please submit your Tiny Tamagotchi MVP with Spec-Driven Development in the reply below.

3

This post is what an example submission looks like! Please note that the repository here is empty, but yours should be filled with the specs you created!

  1. Link to a Github repo that contains the specs (with this specific file structure). Please make sure this repository is set to be Public!
  2. Link to a Loom video demonstrating the web app that was built with these specs.
5

Please find my submission to the challenge

  1. Github repo: GitHub - jlgarciatucci/Tiny-Tamagotchi-MVP: Tamagotchi-style web app using spec-driven development · GitHub
  2. Loom video: Tiny Tamagotchi MVP with Streamlit and Supabase | Loom

App is deployed in streamlit: https://tiny-tamagotchi.streamlit.app/

Hope you like it best regards

6

:hatching_chick: Tiny Tamagotchi - SDD Submission

GitHub Repository Link: https://github.com/SaurabhGithug/tiny-tamagotchi

Attached is my submission for the Spec-Driven Development challenge. The project uses a pure logic-separation architecture to ensure high testability, with the core simulation independent of the UI layer.

:file_folder: Documentation Folder Structure

The documentation/ folder is organized to meet all Spec-Driven evaluation criteria:

  • /specs: Contains Global Constitution documents including Mission, Roadmap, and Tech Stack.

  • Feature Folders: Each folder contains a feature-plan.md, requirements.md, and validation.md for the following modules:

:film_frames: Demonstration

A full video walkthrough of the app in use is included in the project root:

8

Wow, this is awesome! Love the added speech bubbles associated with the chick and how the bars start from 0.

9

Thank you for your comments @Karena_Cai I’m glad you like it

10

[Submission] Tiny Tamagotchi - 7-Day Challenge Submission

GitHub repo (video demo included): GitHub - minhvoio/tiny-tamagotchi: A tiny digital companion that lives in your browser. Feed it. Play with it. Watch it grow. · GitHub

I built a browser-based Tamagotchi pet using a fully spec-driven development workflow from the DeepLearning.AI course.

What it does:
Your pet has three vitals - Hunger, Happiness, and Energy - that decay in real time. Keep it alive with Feed, Play, and Rest. Neglect it and it gets Sick (Heal to recover). Care for it enough and it Evolves permanently. Name it, trigger a Konami code easter egg, and watch its idle animations change with its mood. Everything persists across browser sessions.
Tech stack: Next.js · TypeScript · Tailwind CSS · Vitest · React Testing Library · Playwright (accessibility / browser verification)

How it was built - spec first, code second:
Every feature was written as a spec before a single line of code:

  • specs/mission.md: scope contract and non-goals
  • specs/tech-stack.md: canonical types and tooling decisions
  • specs/roadmap.md: 8-phase delivery plan (Phase 0 → Phase 7)
  • 8 phase folders, each with requirements.md, plan.md, and validation.md
    187 tests across 25 files. All passing. CI green on every push.
11

Submission

#"7-day-challenge"

#"submission"

LIVE APP: https://tiny-tamagotchi-mvp.pages.dev/

Specs

Core loop

https://github.com/brytesika-AI/Tiny-Tamagotchi-MVP/tree/main/core-loop

Pet state system

https://github.com/brytesika-AI/Tiny-Tamagotchi-MVP/tree/main/pet-state-system

Evolution system

https://github.com/brytesika-AI/Tiny-Tamagotchi-MVP/tree/main/evolution-system

Personality / easter eggs

https://github.com/brytesika-AI/Tiny-Tamagotchi-MVP/tree/main/personality-easter-eggs

VIDEO : Tiny-Tamagotchi-MVP/Video_Demo.mp4 at main · brytesika-AI/Tiny-Tamagotchi-MVP · GitHub

12

Hey everyone! :fox:

Here goes my submition:

  1. Github repo: GitHub - MonicaFidalgo/zuki-pet: A Tamagotchi-style virtual pet built from specs · GitHub

  2. Loom video: Zuki Pet App Loom Video

  3. App deployed at: https://zuki-pet.pages.dev/

    7-day-challenge submission

13

Submission: Tiny Tamagotchi Spec-Driven MVP

:link: Links

:clipboard: Project Overview

I built a browser-based Tiny Tamagotchi MVP using spec-driven development, following the challenge’s workflow exactly: write the spec first, then implement the app from it.

The app includes:

  • Pet naming system
  • Three core actions: Feed, Play, Rest
  • Real-time stats: Hunger, Happiness, Energy
  • Passive stat decay over time
  • Pet lifecycle states: Normal → Sick → Dead
  • Game over and restart functionality

:file_folder: Spec Structure

My repo includes the full specification set as required:
tamagotchi-spec-driven-mvp/
├── specs/
│ ├── mission.md
│ ├── roadmap.md
│ └── tech-stack.md
├── features/
│ ├── core-stats/
│ ├── user-actions/
│ └── pet-lifecycle/
├── index.html
├── style.css
└── app.js

:movie_camera: Demo Walkthrough

In the video, I show:

  1. The complete specification folder structure
  2. Naming the pet and starting the game
  3. Using Feed/Play/Rest actions to modify stats
  4. Passive stat decay and state changes (Normal → Sick)
  5. Game over and restart flow

This project follows the spec-driven methodology taught in the course, with the spec being the primary artifact guiding the implementation.

14

Hello everyone,

Here’s my submission for the challenge : 7-day-challenge submission

  1. GitHub repo : GitHub - kksua/virtual-pet · GitHub
  2. Video: https://drive.google.com/file/d/1x-27cTP0d6_v1dsRnpzgJS4V56g_iIn-/view?usp=drive_link
  3. Live app : https://virtual-pet-six.vercel.app/
15

:paw_prints: Submission: Tiny Tamagotchi MVP with Spec-Driven Development

:link: Links

:clipboard: Project Overview

Built a browser-based Tiny Tamagotchi using a fully spec-driven workflow — spec written first, implementation driven entirely by the spec documents.

Features implemented:

  • Pet naming screen with localStorage persistence

  • Three real-time vitals: Hunger, Happiness, Energy with automatic tick-based decay

  • Care actions: Feed, Play, Rest — each with exact stat deltas per spec

  • Dynamic state machine: Normal → Sick → Recovered, Normal → Evolved (permanent)

  • Personality easter eggs: food refusal, tired play reaction, idle quips

  • Retro handheld device UI with CSS keyframe animations per state

Tech stack: React + TypeScript + Vite · Zustand · Tailwind CSS · Vitest · Playwright

:file_folder: Spec Structure

specs/
  mission.md
  roadmap.md
  tech-stack.md

features/
  vitals/          feature-plan.md · requirements.md · validation.md
  care-actions/    feature-plan.md · requirements.md · validation.md
  state-machine/   feature-plan.md · requirements.md · validation.md
  personality/     feature-plan.md · requirements.md · validation.md

Every requirement is tagged with a REQ ID (e.g. REQ-VITALS-001) and mapped to test cases in each validation.md.

16

:cat_face: Tiny Cat — Spec-Driven Development Submission

GitHub Repository: https://github.com/fonsecagabriella/tiny_cat
Live App: TINY CAT
Demo Video: Youtube

Meet Tiny Cat

Tiny Cat is opinionated, unpredictable, and a little difficult to
keep happy. Just like a real cat.

Built as a browser-based Tamagotchi with a retro 8-bit CRT aesthetic —
no framework, no backend, no login. Just you, your cat, and your
questionable life choices.

What’s inside

  • 8 states: Fine, Hungry, Tired, Bored, Happy, Showing Belly,
    Sick, Evolved
  • Real-time stat decay every 30 seconds (Food, Happiness, Energy)
  • Food preference system — your cat has opinions about kibble
  • Full Sick → Recovery flow with poo mechanic
  • One permanent evolution per session
  • Two Easter eggs (the cat will not tell you what they are)
  • Dark/light mode, responsive layout, pixel art inline SVG sprite
  • 81+ Jest tests, GitHub Actions CI green on every push
  • A cryptic in-game help screen titled DECIPHER ME, HUMAN

Spec Structure

Every feature was specified before a single line of code was written.

Each feature folder contains feature-plan.md,
requirements.md, and validation.md.

All requirements carry REQ IDs traceable to test cases.

SDD Workflow applied

  • Constitution was written first, before any code
  • Each phase followed: Plan → Implement → Validate → Replan
  • Constitution updated in the same commit as any logic change
  • Backlog maintained throughout for bugs, deferred features,
    and infrastructure work
  • Agent used: Claude Code

The cat was not harmed in the making of this submission.
It was, however, briefly sick due to an uncleaned poo situation. :poop:

17

Submission : tiny tamagotchi

Here is my submission:
Github : https://github.com/aldrinm/tamagotchi
Demo: Tamagotchi demo | Loom
Deployed at: Tamagotchi

Cheers

18

Tiny Tamagotchi — Submission

Here is my submission for the 7-Day Challenge based on the Spec-Driven Development with Coding Agents short course.

GitHub Repository

https://github.com/bilalibrahimal-oubaidi/tiny-tamagotchi-challenge

Live App

Live App

Loom Demo

Loom Demo

Project Summary

I built a Tiny Tamagotchi web app using a spec-driven workflow. The project includes:

  • one pet

  • three vitals: Hunger, Happiness, and Energy

  • three actions: Feed, Play, and Rest

  • three states: Normal, Sick, and Evolved

  • one recovery path

  • persistence across refresh

  • small personality reactions and easter eggs

Specs Structure

The repository includes the required spec structure, including:

  • specs/mission.md

  • specs/tech-stack.md

  • specs/roadmap.md

and dated feature folders containing:

  • plan.md

  • requirements.md

  • validation.md

Notes

The implementation was developed phase by phase using the written specs first, then implemented and validated against those specs.

Thank you!

20

Here’s my submission:

  1. GitHub repo: GitHub - lukmanaj/tiny-tamagotchi · GitHub
  2. Loom video: Demo

Thank you.

21

7-day-challenge submission
Submission: HabitCat — AI-Assisted Habit Tracker

Hi! This is my submission for the 7-day challenge.

:link: GitHub (documentation):

:movie_camera: Demo video: Watch here

HabitCat is a simple habit tracker with a virtual pet, where daily actions affect the pet’s state (Normal, Sick, Evolved).

The project was built using a spec-driven approach with AI-assisted development.

Thank you!

22

Title: Submission: Cyber Pet OS – Miko Keng

Submission Links:

Project Overview: Cyber Pet OS is a “salvaged 1990s research terminal” virtual pet built using a strict Spec-Driven Development (SDD) workflow. Every logic gate and vital threshold was documented in Markdown before being implemented via AI coding agents.

Key Features:

  • 1:1 Spec Mapping: Vitals (Hunger, Energy, Happiness) and state transitions are strictly bound to technical requirements.

  • Dynamic State Machine: Instant visual feedback with pixel-art assets that swap between Normal, Sick, and Evolved states.

  • Terminal Audit Log: Real-time logging of all system events and state changes.

  • Retro-CRT UI: Authentically styled with scanlines, phosphor glow, and ASCII framing.

23

Hello fellow challenge participants, reviewers, and the DL.AI / JetBrains team :waving_hand:

It’s a real pleasure to share this submission alongside yours. The fun of a challenge like this is that we’re all working the same problem — a Tiny Tamagotchi — from completely different angles, stacks, and instincts, and the aggregate of our attempts is where the real learning lives. Big thanks to Paul Everitt for the course and to JetBrains × DeepLearning.AI for the thoughtful framing of this 7-day sprint. The constitution / plan-implement-validate / replan loop genuinely changed how I think about scoping work with AI coding agents.

A bit about who’s behind this one: I’m an instructor pilot on the T-6 Texan II, and in parallel an MSc candidate in Geography and Applied Geoinformatics at the University of the Aegean. The reason SDD caught my attention isn’t coincidental — the workflow reminded me immediately of aviation checklist discipline. Aviate, navigate, communicate. Spec first, code second, validate always. First things first, and if you skip a step in the briefing, you pay for it later in the cockpit. That framing made the course click for me, and I plan to apply the exact same methodology to future projects where specs preserve intent across sessions.

The project itself is Tiny Tamagotchi — a sci-fi virtual pet on Preact + Vite + Vitest + vanilla CSS, with localStorage persistence and no backend. Stack chosen for a tight MVP: ~3 KB runtime, instant HMR, minimal testing ceremony. What I’d ask reviewers to look at is the SDD trail, not the code: 15 spec files (3 constitution + 4 features × 3 artifacts), 129 unit tests across 6 suites with 100% validation-to-test coverage on the algorithmic features, and a replan branch with a merged PR that tuned Happiness decay from 20s to 35s after playtesting — actual iteration, not waterfall dressed up as iteration. Full transparency on workflow: specs were co-authored with Claude (Anthropic) as pair programmer — every spec reviewed by me before implementation, every feature validated after. The discipline came from SDD; the tool just accelerated the typing.

Quick reference:

Looking forward to exploring everyone else’s submissions — happy to answer any questions about the spec choices or the replan trail. Good luck to all!

— Nick