Forge

Forge is an AI-powered coding mentor for tweens. Guided by Atlas, kids master coding through thrilling, high-stakes missions in Game Design, Space Exploration, Music Tech, and Wildlife Conservation.

Comment

Inspiration

Learning to code is supposed to feel empowering. For a lot of tweens, it feels frustrating instead.

Most beginner coding tools fail in the same way: they either feel like homework, or they become answer machines. Kids get stuck, lose confidence, copy solutions, and never build the resilience that makes programming meaningful.

I wanted to build something different. Forge was inspired by two questions: What if learning to code felt like a mission? What if the AI mentor could tell when you were struggling before you gave up?

Instead of static tutorials and generic chatbot help, I built a world where students solve real coding challenges inside playful, high-stakes missions, while an adaptive AI mentor named Atlas changes how it teaches based on the learner’s behavior in real time. This makes coding feel less like a worksheet and more like a guided adventure.

What it does

Forge is an immersive coding platform for younger learners that combines:

  • Story-driven coding missions
  • A live browser-based code editor
  • An emotionally adaptive AI mentor
  • A progression system designed to keep learners in flow

Inside Forge, students don’t just “do exercises.” They enter interactive scenarios like repairing systems, solving mission-critical bugs, and completing creative technical challenges.

The key differentiator is Atlas, the AI guide. Atlas doesn’t always behave the same way. Instead, it adapts based on how the student is interacting with the editor:

  • If the student is moving smoothly, Atlas acts like a senior engineer, giving light-touch guidance.
  • If the student appears stuck or frustrated, Atlas shifts into a Rubber Duck style and helps them reason through the problem.
  • If the student is trying to brute-force or spam their way through a task, Atlas becomes more skeptical and pushes them to explain their logic.

This means Forge doesn’t just respond to what students ask. It responds to how they’re actually learning.

How I built it

I built Forge as a full-stack interactive learning system optimized for responsiveness, immersion, and adaptive AI behavior.

For the Frontend, I used:

  • Next.js 14
  • React
  • Tailwind CSS
  • Framer Motion

This gave me a fast, app-like interface with animated transitions, game-like polish, and a UI that feels much more like a product than a school tool.

I also integrated Monaco Editor (@monaco-editor/react) so students get a real coding environment directly in the browser.

For the application logic and data flow, I used:

  • Next.js Server Actions
  • Supabase

Supabase handled authentication, learner progress, and persistent mission state, while Server Actions let me securely route AI and telemetry logic without standing up a separate backend service.

For the AI system: Atlas is powered by Google Gemini 1.5 Flash, which I chose because low latency matters a lot in educational interaction. If the mentor feels delayed, it breaks immersion and trust.

The Adaptive Teaching Engine: The most important system I built was my cognitive orchestration layer. Rather than treating Atlas like a static chatbot, I modeled learner struggle using live editor telemetry such as:

  • syntax/runtime errors
  • deletion bursts / backspace frequency
  • idle time
  • interaction patterns over time

I represented cognitive load over a rolling time window, so instead of making AI smarter at answering, I made it smarter at teaching.

Challenges I ran into

1) Making the AI teach without just giving away the answer

Most LLMs are optimized to be helpful by solving the problem immediately. That is the opposite of what a good tutor should do.

Early versions of Atlas were too eager (they would write the loop, fix the bug, or hand over the exact solution). I had to iteratively redesign prompts and system behavior so Atlas would guide the learner with questions, hints, and reasoning instead of replacing the learning process.

2) Bridging editor behavior into meaningful AI signals

I wanted Atlas to react to frustration, but “frustration” doesn’t exist as a built-in variable.

I had to figure out how to infer struggle from noisy browser signals like:

  • repeated edits
  • bursts of deletion
  • long pauses
  • repeated compiler/runtime failures

Turning that into something useful and stable enough to drive AI behavior was a real systems design challenge.

3) Handling complex state between frontend and backend

Monaco Editor state, mission state, telemetry, AI context, and validation logic all had to stay synchronized in real time.

I initially ran into serialization and state-shape issues when trying to pass rich objects across server boundaries. I ended up redesigning my payload structure to make it much flatter and safer to move through the app.

4) Building something polished enough to feel magical

A lot of educational tools fail because they technically work but feel lifeless.

I spent a lot of time on interaction design, motion, pacing, and interface clarity because for younger learners, every little thing matters.

Accomplishments that I'm proud of

This is the first hackathon that I did!! I had no clue about my idea when I walked in here.. All that I knew is that I would be making an AI Agent that would help people.

Built an AI mentor that changes teaching style in real time

Created a coding experience that feels playful, narrative, and high-stakes

Turned browser interaction telemetry into a meaningful adaptive pedagogy system

Made the platform feel polished and intuitive enough that learners would actually want to keep using it

Built a product that sits at the intersection of education, gaming, and human-centered AI

What I learned

Helpful AI is NOT equal to good teaching: A strong educational agent has to know when not to answer directly.

UX matters as much as model quality: Even a great AI experience can fail if the environment around it feels clunky, sterile, or overwhelming.

Behavioral signals are powerful: A learner doesn’t always say “I’m confused,” but their interaction patterns often reveal it.

Simplicity is hard: Behind the scenes, Forge involves orchestration across UI, telemetry, prompt logic, persistence, and code execution, but for the learner, it all has to feel effortless.

What's next for Forge

1) More mission worlds: Expanding beyond a single coding experience into a larger universe of themed missions: creative, technical, and collaborative.

2) Personal learning memory: Atlas remembers how each student learns best over time: when they get stuck, what concepts they struggle with, and what type of guidance works best.

3) Better assessment without killing the fun: Invisible skill tracking that measures growth through behavior, persistence, and problem-solving quality.

4) Collaborative/team missions: Let learners solve missions together with shared AI support.

5) A true emotionally adaptive learning loop: AI personalizes how encouragement, challenge, and support are delivered, making learning feel more human, playful, and resilient.

Built With

Share this project:

Updates