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

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:

1. Opened the plugin menu
2. Selected the LLM plugin
3. 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.

Final Thoughts

Hangul Drop started as a small experiment to test MeDo.

Instead, it became a genuinely playable full-stack game complete with:

• online leaderboards
• backend persistence
• themed content generation
• sound systems
• dynamic gameplay
• daily AI-generated challenges

All built primarily through conversation.

If you want to experiment with AI-native application development yourself:

• Try MeDo here: https://medo.dev/
• Read the docs here: https://intl.cloud.baidu.com/en/doc/MIAODA/s/quick-start-en

The gap between your idea, especially with little to no coding experience, and working software is getting very small very fast!