SkillSprint

SkillSprint turns any skill into a 15-minute adaptive learning journey where AI builds a personalized roadmap and evolves lessons based on how you actually learn over time.

Comment

SkillSprint

💡 Inspiration

In an era of information overload, infinite scrolling has replaced deep focus. While AI has made information more accessible than ever, it has also created a new problem: passive consumption and overdependence. I found myself relying on AI to think, summarize, and solve problems for me instead of actually learning.

At the same time, I noticed that most AI education platforms feel stateless. They generate lessons and quizzes, but they do not truly understand how a person learns over time.

I was inspired by Duolingo’s gamified consistency and Anki’s cognitive science principles, but I wanted to push the idea further:

What if learning worked like a progression system in a game? What if the AI actually remembered how you learn?

That became the foundation of SkillSprint.

SkillSprint transforms any skill into a structured 15-minute daily progression path where the curriculum evolves dynamically based on:

  • user mastery
  • weaknesses
  • confidence trends
  • prior performance

Instead of generating random lessons repeatedly, SkillSprint generates a persistent roadmap once, then adapts future lessons intelligently as the learner progresses.

The result is an AI mentor that evolves with the learner instead of resetting every interaction.

🛠 How I Built It

I built SkillSprint end-to-end using MeDo, which allowed me to rapidly iterate on product architecture, UX design, and AI workflows without getting slowed down by infrastructure complexity.

Frontend

I built the interface using:

  • React 18
  • TypeScript
  • Vite
  • Tailwind CSS
  • shadcn/ui

The UI follows a minimalist monochrome aesthetic inspired by Linear and Duolingo to reduce cognitive overload and keep learners focused.

Backend & Orchestration

I used:

  • Supabase Auth
  • PostgreSQL
  • Supabase Edge Functions (Deno)

The Edge Functions orchestrate:

  • AI generation workflows
  • roadmap persistence
  • adaptive lesson generation
  • mastery tracking

AI Engine

I integrated Gemini through an API gateway and designed a custom Adaptive Context System.

Instead of sending isolated prompts, every lesson generation request includes:

  • prior mastery scores
  • weak concepts
  • learning preferences
  • confidence trends
  • previous node performance

This allows lessons to adapt dynamically to the learner’s behavior.

Progression Architecture

One of the most important decisions I made was separating:

  • roadmap generation from
  • lesson generation

When a user creates a skill, SkillSprint generates the entire roadmap structure once and persists it permanently.

Each roadmap node contains:

  • skill metadata
  • unlock requirements
  • lesson context
  • mastery thresholds

Lessons are generated only when a user opens a node, which reduces unnecessary LLM calls while improving consistency and scalability.

I implemented a Duolingo-inspired progression system using a roadmap_nodes architecture where users unlock subsequent levels only after achieving sufficient mastery.

Mastery is calculated using:

$$ M = \max(M_{current}, S_{new}) $$

Where:

  • $M$ = mastery score
  • $S$ = latest quiz score

A mastery threshold of 80% is required to unlock the next node.

Learning DNA System

I built a Learning DNA Engine that continuously tracks:

  • repeated mistakes
  • pacing patterns
  • preferred explanation styles
  • confidence levels
  • weak concepts

Future lessons and quizzes adapt dynamically based on this evolving learning profile.

🚀 Challenges I Faced

Contextual Continuity

One of my biggest challenges was solving what I call the Memory Gap.

Most AI learning systems generate isolated lessons with no long-term continuity. I needed lessons to feel connected and cumulative.

To solve this, I built a retrieval pipeline that injects:

  • previous lesson objectives
  • weak concepts
  • prior mistakes
  • mastery trends

directly into future lesson generation prompts.

This made the AI feel far more like a real mentor than a static chatbot.

Prompt Engineering for Structure

Generating structured roadmaps consistently was surprisingly difficult.

Early AI responses often returned malformed JSON or inconsistent module structures.

I solved this by implementing:

  • schema validation
  • retry logic
  • strict response formatting
  • structured roadmap templates

This ensured the UI remained stable even during failed generations.

The “Sameness” Problem

Early quizzes became repetitive over time.

To solve this, I introduced adaptive difficulty scaling using an attempt-aware system.

Question complexity and formats evolve dynamically depending on:

  • previous score
  • retry count
  • mastery level

The relationship follows:

$$ Difficulty \propto \frac{\text{Attempt Count}}{\text{Previous Score}} $$

This helped prevent repetitive learning loops and kept sessions engaging.

🎓 What I Learned

Atomic Learning Works

I discovered that limiting users to focused 15-minute learning “nodes” dramatically increases completion rates compared to traditional open-ended courses.

Smaller, structured sessions reduce overwhelm while improving consistency.

AI Works Best as a Curriculum Architect

I learned that LLMs are surprisingly effective at structuring learning progression when given:

  • clear learning goals
  • difficulty constraints
  • mastery thresholds
  • progression rules

Instead of replacing learning, AI becomes a system for sequencing and adapting learning.

UX Matters as Much as Intelligence

Building an AI-first product taught me that perceived responsiveness is critical.

I introduced:

  • animated generation states
  • progression feedback
  • unlock animations
  • “brewing” transitions

to transform AI latency into an engaging experience.

Why MeDo Was Essential

MeDo fundamentally changed how I built this product.

The most impressive part was that it successfully one-shotted complex integrations:

  • LLM orchestration
  • Supabase Edge Functions
  • authentication
  • database workflows

all from the very first implementation prompts.

I believe this worked especially well because I structured the project carefully upfront using a detailed REQUIREMENTS.md specification before beginning implementation.

Instead of spending most of my time wiring integrations or managing infrastructure, I focused almost entirely on:

  • product design
  • learning architecture
  • adaptive workflows
  • rapid iteration

I used MeDo iteratively and conversationally to:

  • refine roadmap structures
  • redesign progression systems
  • evolve the Learning DNA architecture
  • restructure lesson generation logic
  • rapidly test different UX approaches

Several core systems went through multiple iterations before reaching the final architecture.

This iterative workflow allowed me to think like a product architect instead of getting stuck in implementation details.

MeDo enabled me to prototype, test, and refine an adaptive AI learning system at a speed that would have been difficult with traditional development workflows.

Most importantly, it allowed me to focus on what mattered most:

building a deeply adaptive learning experience that feels intelligent, persistent, and personal.

Built With

  • medo
Share this project:

Updates