I Built a Full-Stack Hangul Learning Game by Chatting With AI

A few days ago, I decided to experiment with an AI-powered full-stack app builder called MeDo.

Instead of manually wiring up frontend components, backend APIs, databases, authentication, and deployment, MeDo lets you build applications conversationally -- kinda like pair programming with an AI engineer that already understands your project context and readily updates said context as you progress your conversation with it.

To test how capable it really was, I built Hangul Drop, which is a mini-game for learning to read Korean Hangul.

And surprisingly… most of the app came from natural language prompts.

In this post, I’ll walk through:

What MeDo actually is
How I built the game
How MeDo handled backend integration automatically
Using plugins for AI-generated content
What the workflow feels like compared to traditional development

Quick Demo

If you want to get straight to checking out the app, here's the link to the live app, as published through the MeDo platform itself (see about publishing your own app here):
https://app-b9k9bgvvu1vl.appmedo.com

What is MeDo?

MeDo is an AI-powered full-stack app builder.

You describe what you want in plain English, and MeDo generates:

Frontend UI
Backend APIs
Database integration
Authentication
Application logic
Asset generation
Deployment-ready structure

It also maintains conversational context throughout development, so you can continue refining your app naturally over time.

The official quick start docs are here:

MeDo Documentation

The Goal: Build a Hangul Learning Game

The concept was simple:

Hangul character cards fall from the top
The player types the romanized pronunciation
Correct answers destroy the cards
Missing cards costs hearts
Higher combos increase score
Global leaderboards track players

I also wanted the entire game themed around traditional Korean Hwatu cards.

Normally, building this would involve:

Setting up a game framework
Creating backend APIs
Managing score persistence
Designing a database schema
Wiring leaderboard queries
Creating UI systems
Handling deployment

Instead, I started with a single prompt.

Starting With One Prompt

This was my initial instruction to MeDo:

Create a mini game for learning to read Korean Hangul.

During a game, blocks of Hangul characters will come from the top.

Typing out the romanization of the characters will result in them being destroyed, increasing the player score.

If a character makes it to the bottom it reduces the player's hearts, of which they have three.

When the player loses all their hearts, the game is over.

Then the player can choose to put their score in the leaderboard arcade style by typing out their name.

Score is then recorded in the leaderboard. Where they can compare other players scores.

Visual notes:
Style everything like the classic Korean game Hwatu

What surprised me most was not just that it generated a UI.

It generated an actual working game.

Including:

Gameplay systems
Input handling
Score logic
UI states
Backend leaderboard support
Database integration

Backend Integration Was Automatic

One of the most interesting parts of the experience was backend generation.

MeDo automatically handled the backend stack setup using Supabase.

That included:

Database tables
API integration
Leaderboard persistence
Score storage
Queries
Environment configuration

Normally this is the part that slows down hobby projects the most.

Instead of manually creating schemas or wiring REST endpoints, MeDo simply generated and connected everything as part of the conversation.

I didn’t even need to leave the chat interface.

Iterating Felt Like Talking to a Teammate

Once the first version existed, improving it became extremely fast.

For example, after testing gameplay, I realized players needed recovery time after losing a heart.

So I simply said:

To give players a chance to recover, perhaps after they lose a heart the current characters dropping should be reset. To let the players get their bearing again.

That was enough.

MeDo updated the gameplay logic accordingly.

No hunting through files.
No manually tracing systems.
No context switching.

Just conversational iteration.

MeDo Also Suggests Features Contextually

One thing I didn’t expect was how proactive MeDo became once the project evolved.

As the game matured, it began suggesting relevant improvements based on the current app state.

For example:

Add sound effects
Improve feedback animations
Add combo effects
Enhance transitions

When I accepted the sound effects suggestion, MeDo integrated audio using Phaser and connected sounds contextually throughout gameplay.

Wrong input?
Error sound.

Successful destruction?
Positive feedback sound.

Combo streak?
Enhanced effect.

The impressive part wasn’t only adding sounds; it was understanding where they belonged in the gameplay loop.

Using Plugins to Generate Daily Content

After the core gameplay worked, I wanted a way to keep the game fresh.

This is where MeDo’s plugin system became extremely useful.

Using the built-in LLM plugin support, I created a Daily Theme system.

Each day:

A new theme is generated
A themed vocabulary set is created
A themed dictionary appears in-game
A dedicated leaderboard is attached to that theme

For example:

Body Parts
Transportation
Nature Day
Technology

Players only have one day to top that theme’s leaderboard before the next one replaces it.

Plugin Integration Was Surprisingly Simple

What I liked most about the plugin workflow was how little setup was required.

Inside MeDo, I simply:

Opened the plugin menu
Selected the LLM plugin
Described the feature naturally

MeDo then generated:

The plugin calls
Prompt structure
Data flow
Integration logic

I didn’t need to engineer prompt pipelines manually.

That abstraction layer made experimentation extremely fast.

The Development Workflow Felt Different

What stood out most during this project was how different the workflow felt compared to traditional development.

Usually, building a full-stack app means juggling:

Frontend code
Backend services
Database migrations
API contracts
Hosting
State management
Infrastructure setup

With MeDo, most of that became conversational.

The development process felt closer to:

describing intent
refining behavior
guiding design direction

rather than manually implementing every system yourself.

What I Learned

This was my first time seriously using an AI-native full-stack builder, and it changed how I think about prototyping.

The biggest realization:

AI tools become dramatically more powerful when they understand your project continuously instead of responding statelessly.

Because MeDo maintains context across the app, it can:

improve existing systems
suggest meaningful additions
preserve design consistency
integrate features without re-explaining architecture

That continued flow makes the experience feel less like prompting an AI, and more like collaborating with a technical teammate. A teammate you don't need to brief, as it often knows more than you do.