Driving rocketships without guidance

What was meant to be a simple exercise to practice model-view-controller relationships exploded into an infinite loop where man and machine went on for hours in cycles with no way out.

Last night, I decided to start a new exercise to practice model creation with a simple controller in place. In my head, the idea was simple:

My first mistake was jumping in without writing down a clear plan or mapping out the data relationships in plain English.
 And then I made it worse by asking for validation from the biggest enabler in the world without anything written down.
That was like throwing gasoline on the fire.

I probably came in with too much confidence (I’m still a product person at heart, after all), and the LLM fired back with:

My eagerness to get the learning tool up and running, combined with the LLM’s echo chamber, created a perfect storm that led me to bite off more than I could chew.

Suddenly we had some model relationships I didn’t understand.
 It was getting late, I was tired (my second mistake), and I was getting sleepy. So I just went with it.

All was going great… until it wasn’t.

Suddenly, the seeded data wasn’t matching the questions I was seeing. More precisely, I was missing questions.
 The more I tried to figure it out, the less I understood.
 The data was definitely being seeded. Checking in the console, I could see it in the right place, but the controller, mostly written by the LLM, in code I couldn’t fully read, was a mystery.

I added some debug calls, and the LLM kept insisting it had found the issue. Then it kept tweaking the logic, over and over.
 Whatever little grasp I had of the relationship between my models and controller was now gone.

It was late.
 I was sleepy.
 I was no longer in control, and the LLM kept insisting that this time it would work.

I mean, it was telling me why it had to work, it was so confident that I kept making the mistake of trusting it.

The more it proposed refactoring the start function to reset persistent progress, or adjusting the show method to make sure we were calling the right level, the less I understood what was going on.

We started very vanilla with me writing the first functions and structure (which you could clearly tell by the number of lines I need to write a conditional statement) and ended up, to my perception, in the most minimal, compressed, advanced way of writing code, so that I had no clue what was going on anymore.

Needless to say, after wasting what could have easily been two hours in the most frustrating, infinite-loop-like conversation with a machine, I gave up.
 I apologized to HAL for insulting it, closed the laptop, and went to sleep.

The next morning, after reflecting on the point of what I’m doing, I decided to try again, but this time in a new branch, and not before writing down a plan of action.

So I came up with this:

Learning Tool Schema

Question
(title:string, description:text, category:string, difficulty:string, explanation:text)
→ has many answers
→ belongs to one category
→ has a difficulty
→ has an explanation (we show it only when the user fails the question)

Answer
(text:text, is_correct_answer:boolean)
→ belongs to a question
→ indicates if it’s the correct answer (boolean)

Level
(optional or future dev)

I branched out, started with a new controller and models, and had a working prototype after a short while.

It doesn’t yet have the features I want, like upvoting or downvoting questions, or multiple levels of progression through the questions as you get 90% or more right—but now that the basics are in place, I can build the rest in a future experiment.

After all, the goal is to practice, not to ship a production-ready project.

What became clear to me after this exercise is that I need to practice my routes more.
 I’m still not confident about how to properly route methods inside controllers, especially when they’re nested.

I mean, by shotgunning combinations of names, I eventually get it to work, but as of now, I still don’t feel confident about when to write the name of the folder before or after the parent (or whatever it’s called).

That being said, I now have a tool to write flashcards with different setups that require routing and tricky answer logic, just what I need to keep practicing until I actually know how to do it.

You can check it out at Experiment nr3 inside
novakun.com/projects

Maybe by the time anyone is reading this, I’ll have added fancier logic to the experiment, and you’ll get to write some questions for me or anyone else to practice their coding trivia skills.