SHIP / 01
Vibe Coding for Kids
Rung-one projects at kid scale: games and gadgets finished weekly in Scratch, with the finishing habit installed early.
Open the syllabusProject ideas · Graded by rung · Live online · Worldwide
The internet has no shortage of project lists. What it lacks is honesty about why student projects die: they are chosen too large, they hide a difficulty nobody warned about, and they have no finish line. This page fixes all three. Twelve ideas graded across four rungs, from a first afternoon to a portfolio piece, each with the trap inside it named in advance, because the trap is the education. Then the 21-day plan we use in class to walk a student from idea to shipped, and what reviewers of every kind actually look for when they meet the result.
Live online · ages 6 to 67 · taught from India, worldwide · from USD 100 a month · first class free
Start here
Every idea below is the kind of thing these courses finish weekly, with a teacher doing the scoping and a batch doing the witnessing.

SHIP / 01
Where most of the projects on this page get built: three finished builds a term and a chosen project demoed to families in week twelve.
Open the syllabus →
SHIP / 02
For students who want their projects judged: scoping under time pressure, pitching, and building things that demo well without lying.
Open the syllabus →
SHIP / 03
The portfolio rung as a course: projects with real users and deploys, built to survive an interviewer's questions.
Open the syllabus →The short answer
Good vibe coding projects for students share three properties: they are small enough to finish, they solve an irritation the student personally feels, and they contain one honest difficulty that forces learning, like persistent state, a live data source, or two users wanting the same thing. This page grades twelve such ideas across four rungs from first afternoon to portfolio piece, names the trap inside each, and lays out the 21-day idea-to-shipped plan used in Modern Age Coders classes. Reviewers of finished projects reward four things: it runs live, a note explains one decision, someone real has used it, and the student can tour the code cold. Classes run worldwide at USD 100 a month for groups, USD 150 one to one, first class free.
The ladder
Reaim any of these at your own life freely; the rung and the trap are what matter, not the noun. The trap is not a warning, it is the syllabus.
The pocket-money ledger. Three buttons: earned, spent, balance. The trap is money itself: decimals that drift and spending more than you have, which is to say validation, the first real concept. The chore rotator. Whose turn is it, across three siblings and five jobs? The trap is fairness over weeks, which quietly requires state that survives closing the tab. The homework countdown board. Every deadline, sorted, with days remaining. The trap is dates: time zones, midnight, and what "3 days left" means at 11 p.m.
The bus-stop mirror. One page that answers "coat or no coat" from a public weather source. The trap: the source will be down one morning, and the page must say so instead of lying. The quiz-night scoreboard. Teams, points, a winner. The trap is the disputed point and the tie, the first taste of rules as code. The stubborn flashcards. Cards you get wrong return sooner. The trap is that scheduling logic is real logic, and the model will get it subtly wrong first try.
The league table. Fixtures in, standings out, for any local competition. The trap is ordering: points, then goal difference, then what? Real tables have tiebreak rules and now the student does too. The club signup sheet. Twenty places, first come first served. The trap is two people taking the last place at once, the gentlest possible introduction to a race condition. The reading log. Books, ratings, covers fetched from a public book API. The trap is other people's data: missing covers, three editions, absent authors.
The revision planner. Exam dates in, a day-by-day plan out. The trap is constraints that clash, when there are more topics than days. The recycling reminder. What goes out tonight, per your area's actual rules. The trap is that civic data is inconsistent, and handling mess gracefully is a senior skill. The commissioned tool. Built for one real user who is not you, to their requirements. The trap, and the crown: they will want something you would never have guessed, and you have to ask.
The difference between dying and shipping
Here is the single conversation that decides a project's fate, shown honestly. It happens in week nine of our teen track and in the first class for anyone who arrives with an idea.
"A fitness app. You log workouts, it makes graphs, there are streaks and badges, you can follow friends, there's a leaderboard, maybe an AI coach that suggests workouts, and it works on phones as an app." # Seven features. Four systems. # Accounts, social, notifications, # app stores. Estimated honestly: # four months. Available: three weeks.
Nothing is wrong with this dream. As a first scope it has a survival probability of roughly zero, and every abandoned-project pile is made of exactly these.
"MY pushup tracker. One user: me. Each day: date, count, ten seconds to log. One chart: last 30 days. One streak number. Works in my phone's browser. Nothing else. v2 IF v1 survives two weeks of real use: my brother gets one." # One feature done well, one chart, # one real user, three weeks, ships.
Same dream, first slice. The student who ships this learns more than the student who abandons the grand version, and, crucially, still wants to build v2.
The scoping move is always the same three questions. Who is the one user this must work for? What is the one action they do daily? What can be deleted and added back later? Vibe coding makes starting so cheap that scoping is now the scarce skill: the model will happily scaffold the four-month version on day one, and the wreckage looks impressive right up until it is abandoned.
What reviewers reward at the far end has nothing to do with size either. A project that runs live at a link, a short note explaining one decision and one failure, evidence one real person used it, and a builder who can tour the code cold: those four signals beat scale and polish in school showcases, hackathons and interviews alike, and every rung on this page's ladder is designed so all four are reachable.
The plan
The rhythm we run rung-three projects on, in class and out. Evenings, not heroics, and every phase ends with something that runs.
The three scoping questions, answered in writing: one user, one daily action, everything else deleted. The spec is ten lines in the style this page's right-hand panel shows, and it is the contract the student checks every prompt against for three weeks.
Every part exists and connects, nothing is pretty, the trap has been met. The league table sorts wrongly, the API fails rudely, and that is on schedule: meeting the trap early is the whole reason the trap was named in advance.
The week the project earns its place in a portfolio. The tiebreak rule gets written, the down API gets a polite fallback, the race for the last club place gets settled. This is also the week the student reads more code than they prompt, on purpose.
The hardest exercise we set: hand it over and say nothing. Where the user hesitates is the to-do list. Students discover their labels are riddles and their obvious button is invisible, and no amount of teacher feedback substitutes for this fifteen minutes.
Fix the top three findings only. The rest go in the note as known limits, which reviewers respect far more than they respect the word "coming soon". Feature-adding past day 19 is how day-30 projects are born, and day-30 projects are how abandonment starts.
A live link, a two-paragraph note covering one decision and one thing that went wrong, and an audience of at least one. In class this is demo day; at home it can be the family group chat. Shipping to silence is only half a finish.
The catalogue
Project-based is not a format we bolt on; it is how every track here already works. These are the ones students on this page choose.
SHIP / 01
Rung-one projects at kid scale: games and gadgets finished weekly in Scratch, with the finishing habit installed early.
Open the syllabusSHIP / 02
The ladder's main home: rungs one to three across a term, ending in a scoped chosen project and a demo day.
Open the syllabusSHIP / 03
Projects under judgement: timeboxed builds, honest demos and pitches, for students who want competition stakes.
Open the syllabusSHIP / 04
Rung four as a way of life: deployed projects with real users, built to withstand interview questioning.
Open the syllabusStudents shipping from this page also take Full-Stack Web for Teens · App Development for Teens · JavaScript for Teens · Git and GitHub for Teens · Data Science for Teens · Python for Teens · Hackathon Prep for Kids. The full set is on the catalogue.
Fees
Project teaching costs what all our teaching costs. The figures are flat across every country we serve outside India, and a family can leave at any month end without a retention call.
Free first class
USD 0
no card required
Group batch
USD 100
a month, billed in US dollars
One to one
USD 150
a month, billed in US dollars
What learners and families say
Real reviews from real families. We neither write nor commission them.
★★★★★
"The one step solution for my son. Modern Age Coders make learning coding so simple that kids love it. The teachers explain complex concepts clearly with practical exercises and interactive content."
Ria Mukherjee
Parent
★★★★★
"Modern Age Coders has been a game-changer for me. I struggled to grasp IT concepts and coding before joining, but their classes transformed everything. I can now confidently write complex programs with ease."
Samriddha Mondal
Student
★★★★★
"One of the most wonderful education centres out there. Education is not limited to school syllabus but focuses on skill development."
Vansh Agarwal
Student
★★★★★
"My child Dhairya is really enjoying the Modern Age Coders classes. This is his first online class and he eagerly looks forward to it. I can already see his improvement, and the teachers are very cooperative."
Sonam Oswal
Parent of Dhairya
★★★★★
"Modern Age Coders have wonderful teachers who teach in a clear, easy and practical way. The teacher boosts students' confidence and inspires them to learn without hesitation."
Sonu Goyal
Parent
★★★★★
"I highly recommend this computer coding class! The teachers are incredibly knowledgeable and passionate about coding."
Ritu Kedia
Parent
The rest of the series
This page is the project ladder. The definition, the age tracks and the deciding-parent pages each stand on their own.
Questions about student projects
From irritation, almost always. The best student projects we see solve something that annoys the student weekly: a sibling dispute, a lost permission slip, a team whose fixtures nobody can find. Ideas from lists, including this one, work best as templates you re-aim at your own life. An idea the student did not choose survives about two weeks; an irritation they personally feel survives the debugging.
It counts as practice, and practice is fine. It becomes a project the moment it diverges: a feature the video never built, a redesign for a real user, a version that handles the messy cases the tutorial skipped. Our teachers force that divergence deliberately, because the divergence is where following ends and building begins.
First-rung builds are an afternoon. Stretch builds are a weekend or two. A term project deserves about three weeks of evenings, and our 21-day plan on this page exists because that length forces real scoping without exhausting a school-term attention span. Anything projected to take months should be cut down until it fits, not because ambition is bad but because finishing is the skill being trained.
From the teen years onward, yes, and earlier than most people expect. Version history is the honest diary of a project: it proves the work happened over time, it makes wrong turns recoverable, and it is the difference between a folder of files and something you can show. We teach Git in the teen track for exactly this reason, and there is a dedicated Git and GitHub course when a student is ready to do it properly.
Policies vary by event and are changing every season, so the only safe rule is the one we teach: disclose the AI use plainly, and be able to explain every part of the project without the AI present. Judges consistently forgive assistance and consistently punish the student who cannot answer what a line of their own project does. Being interrogatable is the real requirement, whatever the written policy says.
Yes, with one condition that saves the friendship and the project: split by parts, not by turns. One owns the data and logic, the other owns the interface, and they integrate weekly. Taking turns at one keyboard produces a project neither can explain and an argument about whose idea it was. Split ownership produces two students who each own something completely.
Four signals, in the order reviewers meet them: it runs, live, at a link that works on their phone; a short written note explains one decision and one thing that went wrong; a real person other than the builder has used it; and the builder can tour the code cold. Notice that none of these is visual polish. A plain tool with those four beats a beautiful demo missing them, in classrooms and interviews alike.
Normal, and worth changing. The pile usually means projects are being chosen four sizes too large, which vibe coding encourages because starting is now so cheap. The fix is not discipline lectures, it is the finishing experience: one deliberately small project taken all the way to shipped changes how a student chooses forever after. That is why our terms end in demo days rather than in syllabus completion.
Group batches of five to eight are USD 100 a month and one to one is USD 150 a month, the same in every country we teach outside India, with no enrolment charge and no minimum stay. Every track is project-based; it is not a premium format we charge extra for, it is just how we think teaching works.
Perfectly: send the form and mention the idea. The free first class starts scoping it on the spot, which is the fastest possible demonstration of how we work, and the student leaves with the idea cut to a finishable size and its first slice already running. Arriving with no idea is equally fine; rung one of the ladder above exists precisely for that.
Start
The free class on this page has a specific shape: bring the project, any project, and watch a teacher run the three scoping questions on it live, then build the first slice with the student before the call ends. It is the 21-day plan's first two days, compressed into ninety minutes, and it works as an honest sample of everything we do. No idea yet? We keep a shelf of rung-one irritations ready, and every student turns out to have one of their own within ten minutes of being asked the right way.
More background reading: what vibe coding actually is, the teen track where the ladder lives, or what our students have built.
WhatsApp us · +91 91233 66161 · contact@modernagecoders.com
Teaching is live video from India, worldwide, and the number above is an Indian line. Sending the form books nothing and costs nothing; it starts the phone call in which everything else gets decided by you.