I Built CampusCopilot — A Personal AI Learning System for College Students
#devchallenge #weekendchallenge #hf26challenge
Hacktoberfest Weekend Challenge: Build for a Friend 🤝
🚀 CampusCopilot — Your Personal AI Developer Campus
What if your AI didn't just answer your study questions, but actually understood where you were struggling and told you what to work on next?
I built CampusCopilot for a college friend who was struggling with DSA, coding practice, study materials, assignments, and exams.
Instead of building another generic AI chatbot, I wanted to build something that connects the entire learning process:
Study → Practice → Make mistakes → Understand weaknesses → Get a better next step
The result is CampusCopilot — a personal AI learning workspace for college students.
🎯 The Problem
College students often have everything scattered across different places.
Notes are stored in PDFs.
Coding practice happens on different platforms.
Assignments are tracked separately.
Exam dates live in calendars.
And when students use an AI chatbot, the conversation usually doesn't become an actual learning plan.
I wanted CampusCopilot to answer a different question:
"Given everything this student has been doing, what should they do next?"
🧠 The Core Idea
Most AI learning tools follow:
Question → Answer
CampusCopilot tries to create:
Study → Practice → Performance → Weakness → Recommendation → Action
The AI isn't only there to answer questions.
It should help the student decide what to do next.
📸 CampusCopilot in Action
🏠 Dashboard
The dashboard answers:
"What should I do today?"
It brings together:
- Next Best Move
- Today's Focus
- Study time
- Topics completed
- Quiz accuracy
- Coding problems solved
- Current streak
- Weakest areas
- Upcoming deadlines
📚 StudyBuddy
StudyBuddy turns uploaded study material into an interactive learning workspace.
💻 CodeExplain
CodeExplain focuses on understanding bugs instead of simply copying fixes.
📅 Campus Planner
Campus Planner brings exams, assignments and daily tasks into one workspace.
📊 Learning Profile
The Learning Profile turns learning activity into meaningful insights.
🔄 The Learning Loop
This is the core idea behind CampusCopilot:
Study
↓
Practice
↓
Make mistakes
↓
Identify weak areas
↓
Update learning profile
↓
Recommend next action
↓
Practice again
For example, if a student repeatedly struggles with recursion and has low practice accuracy, CampusCopilot can identify it as a weak topic and recommend a focused practice session.
Instead of simply saying:
"Here is an explanation of recursion."
It can say:
"Recursion is currently one of your weakest areas. Spend 35 minutes practicing it."
The goal isn't just to provide an answer.
The goal is to help the student make progress.
📚 StudyBuddy
StudyBuddy turns uploaded study material into an interactive learning workspace.
It provides four learning modes.
🔎 Ask
Ask questions about uploaded study material and retrieve relevant context before generating the response.
👨🏫 Teach Me
Learn a concept progressively through:
- Simple explanation
- Code example
- Intuitive analogy
- Quick check
🧠 Quiz Me
Practice with questions and track performance.
🆘 I'm Stuck
Get a concept re-framed using different explanations, analogies and problem-solving approaches.
The idea is to make studying interactive instead of simply reading PDFs.
🔎 Grounded Study Assistance
For uploaded study materials, CampusCopilot uses a retrieval pipeline:
PDF → Text Extraction → Chunking → TF-IDF Retrieval → Cosine Similarity → Relevant Context → Llama → Grounded Response
This helps StudyBuddy focus its responses on the student's own uploaded material instead of treating every question like a completely generic chatbot request.
💻 CodeExplain
As a CSE student, one of the most frustrating experiences is getting code that doesn't work and not understanding why.
CodeExplain focuses on teaching rather than simply fixing.
It breaks problems into six stages:
- What happened — simple error explanation
- Why it happened — underlying programming concept
- Where — exact location in the code
- How to fix it — clean corrected code
- What you should learn — core concept
- What you should practice next — targeted practice
It supports:
- Python
- Java
- C++
- JavaScript
- C
For example, a recursion error isn't treated as just something to patch.
CampusCopilot explains the relationship between the recursive call, the base case and the call stack so the student understands the underlying concept.
"Don't just fix my code. Help me understand why I made the mistake."
📅 Campus Planner
Campus Planner brings exams, assignments and tasks into the same workspace.
Students can manage:
- Upcoming exams
- Assignments
- Daily tasks
- Priorities
- Deadlines
It also includes Build My Study Plan.
A student can provide:
- Available study hours
- Subjects
- Exam dates
- Confidence levels
CampusCopilot can then generate an intelligent, time-blocked study plan.
📊 Learning Profile
The Learning Profile turns learning activity into something meaningful.
It tracks:
- Study time
- Quiz accuracy
- Coding problems solved
- Topics mastered
- Weak topics
- Current streak
- Learning progress
Instead of showing only activity numbers, the profile helps answer:
"What am I good at?"
"Where am I struggling?"
"What should I practice next?"
🎯 The Next Best Move
This is one of the ideas I care most about in CampusCopilot.
For example, if a student repeatedly struggles with recursion:
Recursion → 42% Accuracy → Weak Topic Detected → Priority Focus → 35-Minute Practice Session → Quiz → Updated Performance → Updated Recommendation
Instead of simply giving another explanation, CampusCopilot can recommend an action.
The goal is not just knowledge delivery.
The goal is progress.
🔗 The Complete Learning Journey
The different parts of CampusCopilot are connected:
Dashboard → StudyBuddy → Quiz → Learning Performance → Weak Topic → CodeExplain / Practice → Campus Planner → Study Plan → Dashboard
This creates a continuous learning loop instead of a collection of disconnected AI features.
🤖 Why Local AI?
One of the most important technical decisions was supporting a local AI setup.
CampusCopilot can run:
CampusCopilot → AI Service Layer → Ollama → Llama 3.1 8B
This creates a local-first option for working with personal study materials, code and learning context.
The Settings page clearly communicates whether the application is using:
REAL LOCAL AI
or
DEMO MODE
If Ollama is unavailable, CampusCopilot does not pretend that a simulated response came from the local model.
Instead, it provides explicit controls to retry the connection or use Demo Mode.
🏗️ AI Architecture
The overall architecture is:
Student
↓
CampusCopilot Workspace
↓
StudyBuddy / CodeExplain / Campus Planner
↓
Retrieval Layer
↓
TF-IDF + Cosine Similarity
↓
AI Service Layer
↓
Ollama
↓
Llama 3.1 8B
The architecture keeps the AI service layer modular so the application can work with a local model while keeping the rest of the learning system independent from the model implementation.
🧩 Unified State
Another important part of the project is the shared learning state.
CampusCopilot uses a unified application state so that the different sections aren't isolated demos.
The application maintains a single source of truth for the student's learning context using:
campus_copilot_state_v3
stored in local browser storage.
This allows information such as learning activity, tasks, progress and weak areas to remain connected across the application.
🧠 What Makes CampusCopilot Different?
There are already thousands of AI chatbots.
I didn't want to build another one.
The interesting part of CampusCopilot is the connection between the features.
A student can:
Study a topic → take a quiz → perform poorly → have the weak area identified → receive a practice recommendation → practice the topic → see progress reflected in their profile.
That creates a learning loop instead of a collection of disconnected AI features.
🛠️ Technology
Frontend
- React
- TypeScript
- Vite
AI
- Llama 3.1 8B
- Ollama
- Modular AI service layer
Retrieval
- PDF processing
- Text chunking
- TF-IDF
- Cosine similarity
State
- Unified application state
- Persistent local browser storage
Deployment
- Vercel
🎨 Product Design
I wanted the product to feel different from a generic AI chatbot.
The interface was designed as a developer-focused campus workspace rather than a traditional chatbot.
The design uses:
- Dark-first interface
- Optional light mode
- Developer-inspired visual language
- Glassmorphism panels
- Modern typography
- Code-focused UI
- Dashboard-style information hierarchy
- Responsive layouts
- Developer-inspired visual elements
The goal was to make it feel like a personal developer campus, not another ChatGPT clone.
🧪 Testing & Product Readiness
I tested CampusCopilot as a complete student journey rather than only testing individual screens.
The main flows were checked:
- Dashboard navigation
- StudyBuddy
- Uploaded study material interaction
- Grounded question flow
- Quiz flow
- CodeExplain
- Campus Planner
- Study plan generation
- Learning Profile
- State persistence
- Demo Mode
- Local AI connection handling
- Empty states
- Loading states
- Error handling
- Responsive navigation
I also added explicit loading states such as:
- "Thinking..."
- "Analyzing your code..."
- "Preparing your question..."
- "Building your study plan..."
and protected the application against accidental double submissions.
The production build was verified successfully with npm run build with 0 TypeScript or Vite build errors.
🧹 Product Audit & Polish
Before deployment, I performed a complete product audit and removed:
- Obsolete boilerplate
- Console errors
- Duplicate mock data
- Unnecessary hardcoded values
I also added meaningful empty states such as:
- "You're all caught up!"
- "No practice problems solved yet"
- "No upcoming exams scheduled"
The goal was to make the application feel like a complete product rather than a collection of hackathon screens.
🔌 Real Local AI + Demo Mode
CampusCopilot supports two clearly communicated modes.
REAL LOCAL AI
When Ollama is running on port 11434, CampusCopilot can use:
Llama 3.1 8B Instruct
DEMO MODE
If Ollama isn't available, the user can explicitly choose Demo Mode.
The application provides:
[Retry Connection]
and
[Use Demo Mode]
instead of silently pretending that Demo Mode responses are real model responses.
This makes the hackathon demo more reliable while keeping the local AI architecture transparent.
🎥 Demo Video
Watch the complete CampusCopilot demonstration:
The demo covers:
Dashboard → StudyBuddy → CodeExplain → Campus Planner → Learning Profile
🤖 AI Development / Agent Sessions
AI-assisted development was used during the project for coding assistance, debugging, iteration and documentation.
The development process involved repeatedly:
Build → Test → Find bugs → Debug → Improve → Test again
The important part wasn't simply generating code.
The final product decisions, feature design, architecture and testing decisions were made based on the actual product requirements.
🌐 Live Demo
🚀 Try CampusCopilot:
https://campus-copilot-flax.vercel.app/
The deployed version can be explored in Demo Mode.
The local setup supports Llama 3.1 through Ollama.
💻 GitHub Repository
The complete source code is available here:
https://github.com/iam-ayushraj05/campus-copilot
💡 Why I Built It for a Friend
The project started with a simple problem.
My friend didn't need another place to ask an AI questions.
They needed something that could help organize the entire learning process.
They were dealing with:
- DSA practice
- Coding mistakes
- Study materials
- Assignments
- Upcoming exams
at the same time.
That made me think:
"What if the AI could understand all of those signals together?"
That became CampusCopilot.
🌱 Why Open Innovation Matters
For students, AI should not always mean sending every piece of personal context to a remote service.
Study materials, source code, learning history and mistakes can all be personal.
Open-weight models make it possible to explore architectures where AI can run locally and the student has more control over their data and environment.
That's one of the reasons I wanted to experiment with Llama 3.1 through Ollama.
🚧 What I Learned
The hardest part wasn't getting an AI model to answer a question.
It was deciding:
"What should happen after the answer?"
A useful AI learning product needs to connect:
Conversation → Practice → Performance → Weakness Detection → Recommendation → Action
That changed how I think about AI applications.
The AI model isn't the entire product.
The system built around the AI is the product.
🔮 What's Next?
There is still a lot I want to improve:
- Better retrieval and embeddings
- More programming practice
- Richer learning analytics
- More personalized recommendations
- Support for additional local models
- Better evaluation of actual learning progress
- More adaptive quizzes
- Stronger long-term learning memory
But the core idea will remain the same:
Help students understand what they need to learn, why they need to learn it, and what they should do next.
🏆 Built for the Hackathon
CampusCopilot was built for the Hacktoberfest Weekend Challenge: Build for a Friend.
The project started with a real student problem rather than starting with a technology and searching for a problem afterward.
The goal was simple:
Build something a college student could actually use.
The project combines:
- AI-assisted learning
- Local open-weight AI
- Grounded retrieval
- Coding education
- Personalized recommendations
- Learning analytics
- Study planning
- Persistent learning state
All inside one connected developer-focused campus workspace.
❤️ Final Thought
I started CampusCopilot because one student was struggling to keep everything together.
What started as a solution for a friend became an experiment in a bigger question:
"What if AI stopped being just an answer machine and became a learning companion that actually understands your progress?"
That's what I'm trying to build with CampusCopilot.
Study smarter. Understand your code. Know what to do next. 🚀
🔗 Project Links
🌐 Live Demo
https://campus-copilot-flax.vercel.app/
💻 GitHub Repository
https://github.com/iam-ayushraj05/campus-copilot
🎥 Demo Video
🤖 AI Disclosure
AI tools were used during the development of CampusCopilot for coding assistance, debugging, iteration, testing support and documentation.
The product concept, problem definition, feature design, architecture decisions, implementation direction, testing, evaluation and final product decisions were made by me.
Top comments (0)