RightsQuest-APP-Code: The Flutter App That Turns Human Rights Into a Live Curriculum
A small prototype hides a big idea: let users add any right, generate a scenario around it, and grade the answer on shades of moral judgment instead of right or wrong.
- RightsQuest treats human rights education as a generative loop, not a fixed syllabus, so the lesson grows when the learner brings a new right into the app.
- Its most interesting design move is scoring moral judgment on a spectrum, which teaches nuance instead of rewarding memorization.
- The codebase looks like a prototype, but the rough edges reinforce the thesis that the team was proving a learning engine first and polishing production details later.
- Compared with legal reference apps and AI legal assistants, RightsQuest is less about retrieval and more about pedagogy through scenarios.
RightsQuest-APP-Code is interesting because it behaves like a small classroom engine, not a static study app. A user names a right, the app can absorb it into the curriculum, then a backend generates a scenario and the quiz grades the answer across shades of judgment.
A syllabus that grows when the user asks for it
Most educational apps start with a closed set of lessons. RightsQuest starts with a prompt. In levels.dart, the app keeps a hardcoded map of rights categories, but it also lets a user search for something new and add it into Custom Rights when it does not match the preset list.
Developed an application by integrating the Llama 3 model to teach human rights values using gamified scenarios.
The app can turn a new right into new content
That matters because it changes the shape of the curriculum. Instead of asking whether the learner knows the exact item in a predetermined syllabus, RightsQuest lets the learner extend the syllabus itself. The app then asks the backend for a scenario tied to that right, which makes the lesson feel responsive rather than canned.
Why the quiz is built like a moral spectrum
The strongest idea in the repo lives in quiz.dart: a response is not merely right or wrong. The app uses a _pointsMapping with tiers like most_positive, positive, neutral, and negative. That is a teaching choice as much as a scoring choice.
A binary quiz trains recall. This one trains calibration. It asks the user to move toward a more responsible judgment, which fits a domain where context, dignity, and proportionality matter more than trivia.
| Binary quiz | RightsQuest |
|---|---|
| One correct answer | Graded by moral strength |
| Tests recall | Trains judgment |
| Closed question bank | Expandable curriculum |
| Pass or fail | Useful, better, best |
Inside the core loop: levels, API, quiz
The interaction model is straightforward, and that is part of the charm. levels.dart manages the rights list and progress state, ApiService.dart sends the selected right to a backend endpoint, and quiz.dart uses a FutureBuilder to render the generated scenario once it arrives.
The code also shuffles options with Random().shuffle(), which keeps the answer order from becoming a memory game. The result is a small but complete loop: choose a right, fetch a scenario, randomize the choices, then score the response with weighted feedback.
final response = await http.post(
Uri.parse(apiUrl),
body: {'right': rightName},
);
final options = [...generatedOptions]..shuffle(Random());
final score = _pointsMapping[selectedTier] ?? 0;The endpoint itself is telling. The app uses a hardcoded Ngrok URL, which makes the whole thing feel like a live demo wired to a temporary backend. That is a prototype smell, but it also confirms the product thesis: the important part is the loop, not the deployment polish.
A prototype that still reveals a product thesis
The repo’s rough edges are useful evidence. The login screen is bypassed in main.dart, the version number is default, and the network bridge depends on a tunnel that may not survive outside the developer’s setup. None of that weakens the core idea. It suggests the team was spending energy where it mattered most, on proving the learning mechanic.
| Signal | What it suggests |
|---|---|
| Login bypassed | Core flow was prioritized over onboarding |
| Hardcoded Ngrok endpoint | Backend was still under active experimentation |
| Default app version | Early prototype stage |
| Custom rights support | The lesson model was built to expand |
What it is competing with, and why those tools miss the point
| Category | What it optimizes for | Where RightsQuest differs |
|---|---|---|
| Static legal reference apps | Lookup and study | RightsQuest generates scenarios from a user-entered right |
| AI legal assistants | Retrieval, drafting, summarization | RightsQuest teaches through interactive judgment |
| Constitution education tools | Broad awareness | RightsQuest focuses on scenario-based moral calibration |
| Traditional quizzes | Recall and scoring | RightsQuest scores nuance instead of correctness |
That distinction matters. RightsQuest is not trying to be a better law library. It is trying to be a better learning loop. The app’s value comes from making the learner participate in the construction of the lesson.
That is also why the generative backend matters. When an app can synthesize a scenario around a newly entered right, it stops being a catalogue and starts acting like a simulation. For legal literacy, that is a meaningful shift.
Why this model matters beyond one app
RightsQuest shows how Flutter and a generative backend can make an educational domain feel expandable rather than bounded. The subject is narrow, but the pattern is broad. Any field that depends on judgment, not just recall, can benefit from a curriculum that reacts to the learner.
That is the real takeaway here. The repo is small, but its ambition is larger than its file count. It treats legal literacy as a living system, and that makes the project feel less like a demo and more like a prototype for a new kind of classroom.
