I Built FriendOS: An Adaptive AI Learning Companion for a Friend

Shah_Dev — Mon, 05 Oct 2026 06:16:41 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

FriendOS — An AI That Learns How You Learn

Most learning apps ask:

"What do you want to learn?"

I wanted to build something that asks a different question:

"How do you actually learn?"

So I built FriendOS, an adaptive AI learning companion for my friend.

Instead of simply generating explanations and questions, FriendOS builds a learning profile from what the learner actually does inside the application and uses that evidence to decide what should happen next.

What I Built

FriendOS is an AI-powered adaptive learning companion.

A learner starts by providing:

Their name
Their learning goal
Topics they already know

They can then upload their own learning material, such as a PDF.

FriendOS analyzes the material and creates a learning structure from it.

The learner then takes a diagnostic assessment, practices questions, and interacts with the system.

The important part is what happens next.

FriendOS observes measurable learning behavior such as:

Correct and incorrect answers
Number of attempts
Time spent answering
Hints requested
Questions skipped
Topic performance
Difficulty

It then uses this evidence to adapt the next learning recommendation.

For example:

A learner who is struggling with a topic, taking longer to answer, and repeatedly requesting hints may receive:

Review Concept

While a learner who is consistently answering correctly without hints may receive:

Move to Next Topic

The goal is simple:

Don't just teach the learner. Learn how the learner is learning.

The Core Loop

FriendOS follows this loop:

Plan → Act → Observe → Learn → Adapt

1. Plan

The learner provides their goal and learning material.

2. Act

They answer questions and practice inside FriendOS.

3. Observe

The system records measurable behavior.

4. Learn

The system updates the learner's skill and behavior profile.

5. Adapt

The AI recommends the next learning action.

This creates a continuous feedback loop instead of a static question generator.

Demo

🚀 Live Demo: https://friend-os-rho.vercel.app

Try the complete flow:

Create a learner profile
Upload learning material
Take the diagnostic
Practice questions
Submit answers
See the adaptive recommendation

The backend is deployed separately and communicates with the frontend through the API.

Code

The complete project is open source:

GitHub: https://github.com/Codie-ds/FriendOS

The project contains:

Next.js / React frontend
FastAPI backend
MongoDB Atlas database
Gemma-powered AI services
PDF learning-material processing
Diagnostic assessment
Behavior tracking
Adaptive recommendation engine

How I Built It

Frontend

React
TypeScript
Vite
Tailwind CSS

Backend

Python
FastAPI
Pydantic
PyMuPDF

Database

MongoDB Atlas

AI

The core AI model is Gemma.

Gemma is used for tasks such as:

Extracting learning topics from uploaded material
Generating diagnostic questions
Generating adaptive learning recommendations

However, FriendOS does not blindly ask the LLM to calculate everything.

Deterministic calculations such as:

Accuracy
Attempts
Average response time
Hint count
Skip count
Topic performance

are calculated by Python.

Gemma then receives this structured evidence and makes the higher-level learning recommendation.

This separation makes the system more predictable and prevents the AI from inventing behavioral evidence.

From PDF to Adaptive Learning

The complete pipeline looks like this:

PDF

↓

Topic Extraction

↓

Diagnostic Questions

↓

Initial Skill Profile

↓

Learning Session

↓

Behavior Events

↓

Behavior + Skill Analysis

↓

Gemma Recommendation

↓

Next Learning Action

This means the PDF tells FriendOS what should be learned, while the learner's actual interaction tells FriendOS how the learner is performing.

Why Does Open Innovation Matter?

Open innovation made it possible for me to build the core intelligence of FriendOS without treating AI as a black box.

Using Gemma allowed me to build an AI layer that I could integrate directly into my own application architecture.

More importantly, the project combines open AI technology with transparent application logic.

The system doesn't simply say:

"The AI thinks you are weak at Arrays."

Instead, it can ground the recommendation in observable evidence such as:

Low accuracy
Multiple attempts
Frequent hints
Longer response times

That makes the adaptation easier to understand and reason about.

Open innovation also allowed me to combine different open technologies into one system rather than depending on a single closed platform.

What Makes FriendOS Different?

A lot of AI learning tools focus on generating content.

FriendOS focuses on the learning loop.

It doesn't just ask:

"What answer did the student give?"

It also asks:

"What happened while they were learning?"

The goal is to eventually make the system increasingly personalized based on real interaction rather than only a user's initial prompt.

My Agent Session

I used AI coding agents during the development of FriendOS for implementation, debugging, testing, and production-readiness work.

The development process was divided into phases:

Backend foundation
Learning-material processing
Diagnostic assessment
Behavior tracking
Adaptive learning engine
Practice system
Full end-to-end testing
UI/UX refinement
Production security audit
Deployment

I also used automated testing throughout development to make sure the adaptive learning flow remained stable as new features were added.

Production

FriendOS is deployed as:

Frontend: Vercel

Backend: Render

Database: MongoDB Atlas

The application is fully connected end-to-end, including:

User onboarding
PDF processing
AI topic extraction
Diagnostic generation
Skill profiling
Practice
Behavior tracking
Adaptive recommendations

Prize Categories

I'm entering FriendOS for the categories that match the technologies actually used in the project:

Gemma
MongoDB Atlas
Render

What's Next?

FriendOS is currently focused on the core adaptive-learning loop.

Future improvements could include:

Voice-based learning with ElevenLabs
Better learning-resource discovery
More sophisticated long-term learner modeling
Additional learning formats
Spaced repetition
More granular topic mastery
Personalized learning plans

But the core idea is already working:

FriendOS doesn't just teach you. It learns from how you learn.

Final Thoughts

I built FriendOS because I wanted to explore a simple question:

What if an AI learning companion could adapt to your actual behavior instead of treating every learner the same?

The result is FriendOS — a small experiment in building learning software around an adaptive feedback loop rather than just an AI chatbot.

Thanks for reading!

If you try the demo, I'd love to hear what you think.

DEV Community: Shah_Dev