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:
↓
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.
Top comments (0)