DEV Community: Her AI Studio

Build a Tiny Virtual Pet on Arduino in 60 Minutes 🐾

Jen Looper — Tue, 06 Oct 2026 00:47:44 +0000

What if your first hardware project wasn't another blinking LED, but a tiny pet that gets hungry, plays with you, falls asleep, and reacts to what you type?

Meet Kiku. 🌸

Kiku is the mascot and in-house pet of Her AI Studio, a community program helping the next generation of women learn and build with AI.

In this mini workshop, we're shrinking Kiku down until the entire pet can live on an Arduino Uno Q.

Full tutorial is available in the Her AI Studio curriculum

What you need:

an Arduino Uno Q
a USB cable
your laptop
Arduino App Lab
about 60 minutes

Tip! To celebrate Hacktoberfest 2026, swag packs from Major League Hacking are shipping with these Arduinos, so use this workshop for your Hack Day as an introduction to hardware hacking.

Shhh, Kiku is sleeping

By the end, you'll have a tiny Tamagotchi-style pet whose face lives on the board's LED matrix. You'll be able to feed it, play with it, and put it to sleep from your keyboard. More importantly, you'll see how a surprisingly small amount of code can produce behavior that feels alive.

What you'll learn

This project brings together several useful embedded-programming concepts:

flashing code onto physical hardware
communicating with a microcontroller over Serial
drawing graphics on an LED matrix
tracking application state
responding to user input
creating simple animations
building a tiny state machine

If you've mostly written software that stays inside your laptop, there's something especially satisfying about seeing your code suddenly appear on physical hardware.

Part 1: Make sure the board is alive

Before building a virtual pet, start with the embedded developer's version of "Hello, world!": Blink an LED.

Connect your Uno Q to your laptop over USB and open Arduino App Lab which you've downloaded. Login to your board.

Create a new app, and take a look at the scaffolded code. Open sketch.ino, and write a basic blink sketch:

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);

  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
}

Press run in App Lab.

If the built-in LED turns on and off every second, it's aliiiiive!

If the board isn't detected, check your USB cable. Some USB cables provide power but don't carry data.

Part 2: Give your Arduino a way to listen

Now we need Kiku to hear us. We could add buttons or sensors (and we do, in our full workshop with our full AI Kit), but there's a much simpler interface already available: Serial communication.

The same USB connection used to upload your program can carry messages between your laptop and your Arduino while the program is running. In App Lab, it looks like this:

Start Serial communication in setup():

void setup() {
  Serial.begin(9600);
}

Then check for incoming characters:

void loop() {
  if (Serial.available() > 0) {
    char typed = Serial.read();

    if (typed == 'f') {
      // feed Kiku
    }

    if (typed == 'p') {
      // play with Kiku
    }

    if (typed == 's') {
      // sleep or wake up
    }
  }
}

Your keyboard has effectively become the controller for a physical device.

To interact with Kiku, we'll use 3 keystrokes:

f → feed
p → play
s → sleep / wake

Part 3: Give Kiku some feelings

A virtual pet needs more than commands. It needs state. Kiku tracks three simple stats:

int hunger = 3;
int joy = 6;
int energy = 8;

bool asleep = false;

We'll treat each stat as a value from 0 to 10. Now actions can change the pet by incrementing or decrementing these values. Feeding Kiku, for example, reduces hunger (but don't overfeed!):

hunger = max(0, hunger - 3);
joy = min(10, joy + 1);

Playing might make Kiku happier while consuming energy:

joy = min(10, joy + 3);
energy = max(0, energy - 2);
hunger = min(10, hunger + 1);

Make time matter

If Kiku's stats only changed when we typed something, the pet wouldn't feel particularly alive.

So we introduce time! Every few seconds, a tick() function updates Kiku's state, like this:

void tick() {
  if (asleep) {
    // regain energy
  } else {
    // lose energy
    // gradually lose joy
  }

  // gradually become hungry
}

In your code, use a short interval so changes are easy to observe (and change this later when you want your pet to chill out):

const unsigned long TICK_MS = 10000;

That's one update every ten seconds. Walk away from Kiku and come back later, and its state will definitely be different - they can get cranky when left alone!

Give the state a face

Kiku turns its internal state into facial expressions on the Uno Q's LED matrix. We can define its eyes:

enum Eyes {
  EYES_OPEN,
  EYES_CLOSED,
  EYES_HAPPY,
  EYES_PEEK
};

And mouth poses:

enum Mouth {
  MOUTH_FLAT,
  MOUTH_SMILE,
  MOUTH_FROWN,
  MOUTH_OPEN,
  MOUTH_DOT
};

Now our program can translate state into emotion:

Mouth moodMouth() {
  if (hunger >= 7 || joy <= 3)
    return MOUTH_FROWN;

  if (joy >= 7)
    return MOUTH_SMILE;

  return MOUTH_FLAT;
}

Kiku isn't actually experiencing happiness or hunger, of course, but a handful of variables and conditionals suddenly starts to look like personality.

Connect actions to behavior

Now the pieces come together. Your main loop has three jobs:

Listen for commands.
Update Kiku's state over time.
Draw the appropriate expression.

In simplified form:

void loop() {
  if (Serial.available() > 0) {
    char typed = Serial.read();

    if (typed == 'f') feed();
    if (typed == 'p') play();
    if (typed == 's') toggleSleep();
  }

  // update stats when enough time has passed

  // calculate blinking

  // redraw Kiku
}

That's the core architecture of your Kiku. Try it with your own device!

Open the Serial Monitor in App Lab and type:

Kiku eats.

Then:

Kiku plays.

And:

Kiku goes to sleep.

What's next?

Try to make some changes that alters Kiku's personality.

1. Change time

Modify TICK_MS.

2. Invent an expression

Make Kiku wink, act surprised, or act sad.

3. Add another command

Maybe:

c → clean

What did we actually build?

On the surface, we built a cute virtual pet. Underneath, we explored several concepts that appear in much larger systems:

Input handling: Serial commands become events.

State management: Variables remember what's happening between iterations of the loop.

State transitions: Actions modify that state.

Time-based behavior: The system changes even without direct input.

Rendering: Internal state becomes visible through the LED matrix.

Human-computer interaction: Animation and timing make simple logic feel expressive.

If you build your own Kiku for Hacktoberfest, we'd love to see what personality you give it.🌸

This article is presented as a gift to Hacktoberfest hackers by Her AI Studio, a community program for the next generation of women in AI.

The complete Kiku workshop, including the full Arduino sketch, exercises, knowledge checks, and additional resources, is available in the Her AI Studio curriculum.

Is AI Cheugy?

Jen Looper — Mon, 21 Sep 2026 04:00:00 +0000

cheu·gy ˈchü-gē - cheugier; cheugiest. slang: uncool, unfashionable

It's happened enough times that I'm starting to call it a trend: I talk about something - anything - AI-related, and my listener screws their face into a scowl, gives me a robust side eye glare, and beats a hasty retreat. It's as if, when I mention AI, people suddenly are accosted by a bad smell...the stench of the dangerous and icky.

The AI-pilled amongst us, of course, don't really see this. So caught up in their bubble, so sure of the rightness of their course, so excited by the newness of the tech and so enthused by its promise, they are often blind to the legitimate concerns that many (many!) so-called "normies" have about AI. Anyway, they don't talk to normies.

So let's talk about it.

At Her AI Studio, for which this is an interesting inaugural blogpost, our mission is to empower high school aged girls to learn about AI in a safe space - a space for women, coached by female mentors near their age, using physical AI to build cyberdecks. By using locally-run hardware on which we can run small local AI models, we create a "walled garden" where students can safely experiment with local AI. In doing so, we can also discuss weighty topics of privacy, security, data governance, and the ethical questions surrounding AI.

A cyberdeck built with our kit, including an Arduino Uno Q board, small keyboard and monitor, microphone, camera, and USB Hub. Every student can create their own, this is just my fluffy iteration.

That doesn't make AI any less cheugy (and, increasingly, political, although that's a topic for another day). There are serious question about:

From where the training data that has fed the models is sourced
What this technology means for the environment, from training, sourcing materials for hardware, water use, pollution, land use, and more
How AI is really screwing up education (my own particular hot take) and is being actively banned in some districts
How deepfakes are ruining lives
How powerful algorithms are feeding propaganda machines and influencing political outcomes
How copyright rules and ethical concerns about plagiarism are caught up in this new technology
How skills are decaying due to being replaced by a technology that can outsource work in a flash

...and more

Headwinds

It's really important to acknowledge these important headwinds and concerns and understand them. Rather than brush anything aside, I propose to address these head on in our cohorts with full transparency and with the understanding that there are many unsavory aspects of this tech. Reactions such as this from Gen Z commenters crystalize the moment. When seeking applicants for our Youth Board, here's a reaction:

Ouch. But point well taken, and gone are the AI images from the site. We are listening.

It's a fine line we're threading, and the gulf is enormous. At one end, we have folks insisting that AI will be so powerful that in a few years it will end us all. At the other end we have folks who advocate banning it entirely.

There has to be some kind of middle ground. The companies making foundational models aren't doing us any favors by promoting the idea that somehow they have created something that will imminently cause a world cataclysm. By not sufficiently creating robust guardrails to protect users from abuse, they are creating a hostile environment for large swaths of the population.

This is precisely why we founded Her AI Studio. We want to ensure that women will have a role to play in the creation of AI, in the design of its guardrails, in the ethics around the kind of data on which it is trained. Without radical inclusion of these voices, we risk creating an "intelligence" that is stunted, that does not resemble our reality, and that cannot meet the needs of 50% of the world's population.

A new approach

We do not approach the topic from a place of weakness or fear. We are not evangelizing AI, or really any particular product. Instead, we use open models, run locally, on hardware that we own, and talk about what this means. We study how data is used, from where it's sourced, what ethical concerns are raised by both building and using AI, and more.

Because if we stay on our current path, we are going to build an AI that is not only unrecognizable, it's not going to be built to serve the best interests of a lot of people. And we find that unacceptable. Unacceptable and truly cheugy.

Visit HerAIStudio.org to learn more.