#devchallenge #weekendchallenge #hf26challenge Hacktoberfest Weekend Challenge: Build for a Friend 🤝
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.
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?"
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.
"What should I do today?"
It brings together:
StudyBuddy turns uploaded study material into an interactive learning workspace.
CodeExplain focuses on understanding bugs instead of simply copying fixes.
Campus Planner brings exams, assignments and daily tasks into one workspace.
The Learning Profile turns learning activity into meaningful insights.
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.
It provides four learning modes.
Ask questions about uploaded study material and retrieve relevant context before generating the response.
Learn a concept progressively through:
Practice with questions and track performance.
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.
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.
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:
It supports:
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 brings exams, assignments and tasks into the same workspace.
Students can manage:
It also includes Build My Study Plan.
A student can provide:
CampusCopilot can then generate an intelligent, time-blocked study plan.
The Learning Profile turns learning activity into something meaningful.
It tracks:
Instead of showing only activity numbers, the profile helps answer:
"What am I good at?"
"Where am I struggling?"
"What should I practice next?"
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 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.
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.
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.
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.
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.
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:
The goal was to make it feel like a personal developer campus, not another ChatGPT clone.
I tested CampusCopilot as a complete student journey rather than only testing individual screens.
The main flows were checked:
I also added explicit states such as:
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.
Before deployment, I performed a complete product audit and removed:
I also added meaningful empty states such as:
The goal was to make the application feel like a complete product rather than a collection of hackathon screens.
CampusCopilot supports two clearly communicated modes.
When Ollama is running on port 11434, CampusCopilot can use:
Llama 3.1 8B Instruct
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.
Watch the complete CampusCopilot demonstration:
The demo covers:
Dashboard → StudyBuddy → CodeExplain → Campus Planner → Learning Profile
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.
🚀 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.
The complete source code is available here:
https://github.com/iam-ayushraj05/campus-copilot 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:
at the same time.
That made me think:
"What if the AI could understand all of those signals together?"
That became CampusCopilot.
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.
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.
There is still a lot I want to improve:
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.
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:
All inside one connected developer-focused campus workspace.
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. 🚀
🌐 Live Demo
💻 GitHub Repository
🎥 Demo Video
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.