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:
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.
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!
Top comments (0)