Feedy

Inspiration

An anomoyous way for teachers to run a session where students can join anomoyously and ask qustions or mark their current confusion levels. teachers can answer them out loud (not part of the website) and mark them as answered. afterwards, the teacher can end the session and see a chart of questions and where people are confused.

To simplify, this project was built on a fly
We first had two members go over the backend using django that has the models, views, and urls and three others making a figma for the front end design
then we had three people going over the frontend to make the api calls and context, while some other people worked on the static frontend.
- We combined the static and calls togther to make dynamic site.
- Then we deployed it on Cloudlare.
- Ai use is listed bellow

In general, we needed to plan out and delegate tasks better. we came with little to no plan and did things on the fly which lead to a lot of issues such as: -- We were confused what we were doing and what the team was doing in general -- We ran into a lot of merge conflicts due to people working on the same thing at once -- We didn't know what to do after we finished something and people were confused when given code from another person
In general LLMS tend to spit out code that is overly complicated or do things that don't make sense. It took a lot of time understanding what it was trying to tell us and what it was trying to do.

This is our first hack-a-ton so even joining is cool and seeing how it is to work as a team
That we managed to complete this in time
That we have something that might actually be useful for classes/real world
For some of this, is our first time using LLM for a project so it was a learning experience how to work with it

When starting a project, ask other people for what they think of our project before we start working too much on it. We need to see what people feel about it and what is important to people rather than getting too absorbed into making something or coming up with a solution to a problem that doesn't really affect people.
Better team planning so that we can work faster with less confusion and less breaking.
Commit more, so if something breaks it's easier to see what broke it and go to a previous commit that doesn't break more.
LLMS tend to do too much or spit out non-sense code, it's imperative to write good messages and to read carefully through them rather than wave them through and let the entire team suffer because of that.

By the end, the majority of the code was written via AI for both frontend and backend.
AI was used for the backend, writting almost every model, view, and url for about 90% of it done by it via AI. 10% was our own edits and configurations over it.
It was used for the frontend, writting almost every page, component, hooks, and more. About 90% of it was done via AI and 10% was our own editing over it.
However we reviewed and went over it ourselves before it went into the main github repo, we actively dived through the code and made understood what was being written. We were more rushed in the end but it was an active proccess with the ai, it was not all written in a couple of prompts but a lot of back and forth with the AI over what it does.
Figma files were done by hand with some claude suggestions. basically we do some objects by hand and occasonally ask for suggestions by claude for any changes and see if we want to do said changes.
README was generated with AI

the apiClient function was made from an instructor from NAIT, taken from the repo: "https://github.com/NAIT-SDEV2451/SDEV2451-Fall-2026-A02-Instructor-Examples" The repo is ran and made by the instructor Dan Mouris for SDEV2451 - Full Stack Software Development.