AI Tutor

Making Learning Personal: AI That Adapts to Every Student's Journey

Comment

Hackathon Requirements

LLM: ✅ Amazon Nova Pro (AWS Bedrock)
AWS Services: ✅ Amazon Bedrock AgentCore (Runtime + Tools) • Amazon Nova Pro • DynamoDB • Cognito • S3 + CloudFront
AI Agent Qualification: ✅ Reasoning LLM • Autonomous teaching capabilities • External integrations (DynamoDB, Memory Systems, Content Generation)
Functionality: ✅ Fully deployed on AWS (us-east-1) • Reproducible via CDK • End-to-end autonomous learning journeys

Inspiration

I've watched my niece struggle with English homework, alternating between Khan Academy videos (one-size-fits-all explanations) and her overworked teacher (30 students, 45 minutes). Neither works great:

Khan Academy: "Today we're learning about metaphors..."
My Niece: [Already knows metaphors, needs help with subject-verb agreement]
Result: 20 minutes wasted watching the wrong lesson

Her Teacher: Has 7th-grade vocabulary lists, 8th-grade reading standards, and 6th-grade grammar worksheets. She teaches to the middle and hopes everyone keeps up.

Private tutors fix this—they meet students where they are, adapt on the fly, and keep things engaging. But at $50-100/hour, most families can't afford consistent help.

So here's the question: What if I could build an AI tutor that actually adapts in real-time? Not pre-recorded videos, not static worksheets, but an autonomous system that diagnoses gaps, generates personalized lessons, adjusts difficulty based on performance, and makes learning feel like a game. That's AI Tutor: an intelligent teaching agent that meets every student exactly where they are.

What It Does

AI Tutor is an autonomous teaching system that adapts in real-time to each student:

Core Capabilities:

  • Diagnoses skill levels with subject-specific assessments (5 questions, 2-3 minutes)
  • Generates personalized lessons based on diagnostic results and student interests
  • Creates varied quizzes (6 question types: MCSA, MCMA, True/False, Short Answer, Fill-in-Blank, Word Match)
  • Adapts difficulty dynamically - struggling on Section 1? Section 2 reinforces fundamentals
  • Gamifies learning with XP, achievements, streak tracking, and 30 levels (Beginner → Legend)
  • Supports 4 subjects (English, Math, Science, History) with subject-agnostic architecture
  • Structures knowledge into coherent 3-section learning journeys (Foundation → Application → Mastery)

Example Learning Journey:

Meet Alex (7th grader): Struggles with grammar but loves basketball

AI Tutor: [Runs diagnostic, analyzes results...] "I noticed you're strong with reading comprehension (4/5 correct) but subject-verb agreement needs work (1/5 correct). Let's build a personalized lesson about grammar—and since you love basketball, we'll use examples from the sport!"

Section 1 - Foundation: Lesson explains subject-verb agreement using basketball scenarios: "LeBron dribbles down the court" vs "The players dribble down the court." Quiz: 3 questions. Alex scores 2/3 (67%).

AI Tutor: [Analyzes performance, adjusts strategy...] "I see you got the basic singular/plural distinction, but compound subjects confused you. Section 2 will reinforce that specific concept."

Section 2 - Application: Lesson dives deeper into compound subjects with more basketball examples. Quiz adapts to focus on the struggled area. Alex scores 3/3 (100%).

AI Tutor: [Celebrates, increases difficulty...] "Perfect! You've mastered the fundamentals. Section 3 will challenge you with complex sentences and edge cases."

Section 3 - Mastery: Advanced practice with tricky scenarios. Alex scores 2/3 (67%) but demonstrates solid understanding.

Result: In 45 minutes, Alex went from struggling with basic grammar to handling complex cases—all through personalized, adaptive content featuring his favorite sport. He earned 180 XP, unlocked "Grammar Rookie" achievement, and reached Level 3.

MVP Scope:

  • ✅ Real-time diagnostic assessment with AI analysis
  • ✅ Personalized 3-section learning journeys
  • ✅ 6 question types with AI-driven generation
  • ✅ Adaptive difficulty (adjusts per section based on performance)
  • ✅ Gamification (XP, 35+ achievements, 30 levels, streak tracking)
  • ✅ Subject-agnostic design (add subjects by updating constants only)
  • ✅ User authentication (AWS Cognito)
  • ✅ Beautiful UI with Aceternity components (3D cards, animations, particles)
  • ❌ Multi-student classrooms (single student accounts)
  • ❌ Teacher dashboards (future feature)
  • ❌ Parent progress reports (future feature)

How I Built It

Tech Stack

I built this on Amazon Nova Pro for reasoning (because it actually understands the difference between "teach simpler" and "provide examples"), Amazon Bedrock AgentCore Runtime for agent orchestration (session management, tool execution, memory—the foundation), and Python + Pydantic for type-safe data models. The frontend is React + TypeScript with Aceternity UI for gorgeous animations (3D card effects, text generation effects, particle celebrations). Data lives in DynamoDB (student profiles, quiz results, lesson plans, achievements), auth via Cognito, and everything deployed via AWS CDK because clicking around in the console is for people with more patience than me.

Architecture Decisions

Single Agent vs Multi-Agent
I chose one orchestrator agent instead of separate "quiz specialist," "lesson specialist," and "analysis specialist" agents. Why? Because coordinating multiple agents means they're constantly passing messages like a corporate email chain from hell. One agent is faster (no communication overhead), smarter (remembers student context across all tools), simpler (one decision point), and cheaper (one execution path instead of three). Nova Pro's reasoning capability made this work—it reliably decides when to diagnose, when to teach, when to assess, all from context.

Subject-Agnostic Design
Here's what makes this architecture special: adding a new subject requires zero code changes. Want to add History? Update three constants (SUBJECT_SKILL_AREAS, SUBJECT_METADATA, Subject enum) and you're done. The AI agent adapts to any subject automatically because it generates content based on skill areas, not hardcoded templates. This wasn't just clever engineering—it's how you build systems that scale without rewriting everything.

Adaptive Generation, Not Pre-Generation
I explicitly generate content one section at a time and adapt based on performance. The agent doesn't create all 3 sections upfront and hope they're right—it generates Section 1, observes how the student performs, then tailors Section 2 to reinforce weak areas or advance strong ones. This is true adaptive learning, not just personalized content.

Why AgentCore?
I could have spent weeks building custom agent infrastructure—tool registration, memory management, session handling, streaming. Or I could use AgentCore Runtime, which gives me all of that production-ready. I chose sanity. AgentCore gave me conversation memory with proper scoping (per-session state), native Bedrock integration (Nova Pro just works), and automatic error handling so I could focus on making the AI actually teach well instead of debugging infrastructure.

AI-Driven Everything
There's zero hardcoded logic for content. No templates with blanks to fill in. No keyword matching. The AI generates every quiz question, every lesson paragraph, every analysis insight. I provide structure (3-section journeys, 6 question types) and the AI fills it with contextually relevant content. This means lessons stay fresh, adapt to edge cases, and genuinely personalize to student interests.

Gamification as Motivation Engine
Learning is hard. Middle schoolers need more than "good job!" to stay engaged. So I built a complete gamification system: XP for every action (10 XP per correct answer, 50 XP per lesson, 100 XP for perfect quizzes), 35+ achievements across 7 categories (vocabulary, grammar, reading, streaks, speed, accuracy, special events), 30 levels with titles (Beginner → Scholar → Master → Legend), and streak tracking with daily bonuses. It's not just decoration—it's the psychological hook that turns "I should study" into "I want to level up."

Challenges I Ran Into

1. AI Quiz Analysis Without Hardcoding

Students ask diverse things: just flights, complete trips, specific restaurants, follow-ups. Each needs different data, but the frontend needs consistency.

The Problem: Quiz questions need to map to skill areas for meaningful analysis. But I refused to use keyword matching or hardcoded patterns (they break across subjects and with AI-generated content variations).

Failed Attempt #1: Had quiz_analyzer look for keywords like "metaphor," "verb," "equation" in questions. Worked for English until I tested Math—suddenly everything was classified as "unknown skill" because the keywords were wrong.

Failed Attempt #2: Tried asking AI to analyze questions after generation and guess skill areas. Too slow (2 extra AI calls per quiz) and error-prone (AI sometimes hallucinated skill names).

Solution: Modified quiz_generator's AI prompt to explicitly tag each question with skill_areas during generation:

# AI generates:
{
  "question": "Which sentence uses correct subject-verb agreement?",
  "skill_areas": ["grammar", "subject_verb_agreement"],
  "options": [...]
}

Now quiz_analyzer just aggregates the tags:

def analyze_diagnostic_results(quiz_result):
    struggled_skills = [skill for q in questions 
                       if not q.correct 
                       for skill in q.skill_areas]
    return Counter(struggled_skills).most_common(3)

Impact: Analysis went from 60% accuracy with keywords to 95%+ accuracy by trusting AI's own tags. Lesson learned: if you're using AI to generate content, have it generate metadata too.

2. DynamoDB Schema Conflicts

Here's a fun surprise: DynamoDB doesn't let you arbitrarily change partition key structures mid-project.

The Problem: Originally designed lesson plans as separate items with composite key (student_id, lesson_plan_id). Sounded smart until I realized the student table uses student_id as partition key with completely different schemas. Can't query across tables without massive gymnastics.

Failed Attempt: Tried creating a secondary table just for lesson plans. Now I had two sources of truth, sync issues, and extra API calls.

Solution: Store lesson plans as embedded JSON in student profiles:

student_profile = {
  "student_id": "user123",
  "grade_level": 7,
  "interests": ["basketball", "video games"],
  "current_lesson_plan": {  # Embedded!
    "lesson_plan_id": "lp_abc123",
    "subject": "english",
    "sections": [...]
  }
}

Impact: One DynamoDB read gets everything. No joins, no sync issues, atomic updates. Sometimes simpler really is better.

3. Adaptive Difficulty Actually Working

Saying "the AI adapts difficulty" is easy. Making it reliably work is hard.

The Problem: Section generator needed to know previous performance but the agent's tool signature didn't include it. I was generating Section 2 with zero awareness of Section 1 results.

The Fix: Updated section_generator to accept previous_section_performance:

def generate_section(
    section_index: int,
    topic: str,
    previous_section_performance: Optional[Dict] = None  # New!
):
    if previous_section_performance:
        score = previous_section_performance.get("quiz_score", 0)
        if score < 0.5:
            difficulty = "easier"  # Reinforce fundamentals
            focus = previous_section_performance["struggled_skills"]
        elif score >= 0.9:
            difficulty = "harder"  # Challenge them
        # Pass to AI prompt for adaptive generation

Then updated tutor_agent to pass performance from state:

def present_next_section(self):
    previous_performance = self.state.get("last_section_performance")
    section = self.section_generator.generate_section(
        previous_section_performance=previous_performance
    )

Impact: Tested with intentionally failing Section 1 (0/3 correct). Section 2 was noticeably simpler, focused on struggled skills, with more examples. Then tested perfect Section 1 (3/3) and Section 2 ramped up difficulty appropriately. Adaptation actually works now.

4. Quiz Result Saving Gap

Built the entire quiz analysis system before realizing... quiz results weren't being saved to DynamoDB.

The Problem: Frontend displayed quizzes, collected answers, evaluated correctness—but never persisted to backend. So quiz_analyzer was trying to analyze non-existent data, falling back to mock data, and generating nonsensical lesson plans.

The Facepalm Moment: Spent 2 hours debugging why lesson plans weren't adapting to diagnostic results. Checked AI prompts (fine), checked analysis logic (fine), checked DynamoDB queries (returning null). Finally realized: "Oh... I never actually save the quiz."

The Fix: Added save_quiz_results tool to backend:

def save_quiz_results(quiz_id: str, subject: str, questions: List[dict]):
    # Save to DynamoDB with full evaluation data
    dynamodb.save_quiz_result({
        "quiz_id": quiz_id,
        "student_id": student_id,
        "questions": questions,  # Includes answers + correctness
        "score": calculate_score(questions)
    })

Updated frontend to call after quiz completion:

const handleQuizComplete = async (questions) => {
  const evaluation = evaluateQuiz(questions);
  await api.saveQuizResults(quizId, subject, evaluation);
  // Now analysis has real data!
}

Impact: Quiz analysis went from "using mock data" to "using real student performance." Lesson plans suddenly made sense because they're based on actual diagnostic gaps instead of fake ones.

5. Subject Selection UX Design

Originally had students select their subject during onboarding. Seemed logical until I thought about it for 5 seconds.

The Problem: If you pick "English" during onboarding, you're locked into English forever (or have to re-onboard). But students might want to learn Math today, Science tomorrow, English next week. Making subject a profile attribute was wrong.

The Fix: Two-part redesign:

  1. Removed subject from OnboardingPage (now just grade + interests)
  2. Added SubjectSelectionView as first state in LearningJourneyPage

Now the flow is:

Onboarding (once) → Grade + Interests
↓
Each Session → Pick Subject (English/Math/Science/History)
↓
Diagnostic → Personalized Journey → Summary
↓
Return to Subject Selection (pick same or different subject)

Impact: Students can freely explore all subjects without friction. Each subject tracks progress independently. One student profile, four subject progressions. Much better UX.

Accomplishments I'm Proud Of

🎯 Fully deployed production system on AWS—not localhost, a real application with CloudFront CDN, API Gateway, and auto-scaling

🤖 True adaptive learning—not "personalized templates," but real-time difficulty adjustment based on observed performance

🎮 Complete gamification system—35+ achievements, 30 levels, XP calculations, streak tracking, rarity tiers (Common → Legendary)

🏗️ Subject-agnostic architecture—add new subjects by updating 3 constants, zero code changes required

🧠 AI-driven everything—no hardcoded templates, keyword matching, or decision trees; everything generated by Nova Pro

📱 Beautiful, responsive UI—Aceternity components with 3D effects, smooth animations, particle celebrations

🔄 Intelligent question variety—6 different question types with AI-generated content for each

📊 Comprehensive data model—type-safe with Pydantic/TypeScript, single source of truth for enums

What I Learned

Nova Pro's reasoning capability is seriously impressive: I initially worried it wouldn't consistently understand "make this harder" or "focus on grammar," but it reliably interprets context, adapts content, and makes teaching decisions that feel genuinely reasoned. The difference between GPT-3.5-class models and Nova Pro for agentic workflows is night and day—this feels like an actual tutor, not a pattern matcher.

Subject-agnostic design scales beautifully: Designing for "any subject" from day one seemed like over-engineering, but it paid off immediately. Testing English, then Math, then Science required zero code changes—just content generation. The architecture constraints (skill areas, metadata, subject enums) forced clean separation that would've been messy otherwise. Sometimes abstraction isn't premature, it's strategic.

Adaptive generation beats pre-generation every time: I could've generated all 3 sections upfront and called it "personalized," but real adaptation requires observation → adjustment → observation. Seeing students struggle on Section 1 and then generating a reinforcing Section 2 produces qualitatively better learning outcomes than guessing difficulty ahead of time. The extra API calls are worth it.

Gamification isn't just motivational decoration: The achievement system (35+ badges across 7 categories) and XP progression (30 levels, exponential curve) transformed beta testers' behavior. Students who previously did "the minimum" suddenly wanted to hit streak milestones or unlock rare achievements. The psychology of progress bars and badges is real—it turns obligation into aspiration.

Type safety saves debugging time: Pydantic on backend, TypeScript on frontend, shared constant enums—this wasn't just pedantry. It caught mismatched enum values, missing fields, and type mismatches before they became runtime bugs. The upfront investment in type definitions paid for itself 10x over.

DynamoDB embedded documents > multiple tables: Fighting DynamoDB's schema to maintain normalized data was misery. Embracing embedded JSON (lesson plans inside student profiles) simplified queries, eliminated sync issues, and made state management trivial. Sometimes NoSQL patterns are weird, but they work.

What's Next for AI Tutor

Multi-Student Classrooms: Teacher dashboards to manage 20-30 students, assign specific lessons, track class-wide progress

Parent Progress Reports: Weekly summaries emailed to parents with skill improvements, time spent, achievements earned

Voice Interface: Let younger students speak answers instead of typing (accessibility + engagement)

Collaborative Learning: Pair students for peer review, group challenges, competitive leaderboards

Content Library: Let teachers upload custom lessons, quizzes, or reading materials for AI to incorporate

Advanced Analytics: Predict struggling concepts before students fail quizzes, suggest intervention strategies

Mobile Apps: Native iOS/Android with offline lesson caching, push notifications for streak reminders

More Subjects: Add Social Studies, Foreign Languages, Computer Science (just update the constants!)

Long-Term Memory: Track learning style over months, identify patterns ("You learn grammar best through sports examples")

Real-Time Tutoring: Live chat with AI tutor for homework help, not just structured lessons

Achievement Showcase: Public profiles to share rare badges, social proof for accomplishments

Share this project:

Updates

Submission history