The idea started much smaller
About a year ago, I was fascinated by AI, but I was also starting from almost zero. I wanted to build something that felt like my own AI product. My first attempts were much simpler: I would take an existing AI API, connect it to a frontend, make a chat box, and feel like I had built an AI.
Technically, I had built something. But I knew the important part was still happening somewhere else. The model was not mine. I was sending a prompt to an API and displaying the response.
That realization became the starting point for everything that followed.
YouTube, experiments, and a lot of confusion
I did not start with a perfect roadmap or a formal AI curriculum. A huge part of my learning came from YouTube videos, documentation, examples, and then trying to reproduce what I had just learned.
Some days I understood a concept. Other days I would watch the same kind of explanation again because I still could not figure out why my code was breaking.
I learned by building. I copied ideas, changed them, broke them, fixed them, and eventually started understanding why they worked. Trial and error was not a side effect of the process. It was the process.
The moment APIs stopped being enough
As I learned more about machine learning and language models, I became increasingly curious about what was actually happening underneath the API.
What is a tokenizer doing? How does a Transformer process text? What happens during training? How do weights learn patterns? What does it take to turn a pile of text into a model that can actually generate language?
Those questions were much harder than simply wiring an API into a website. They were also much more interesting.
Why I decided to build it from scratch
At some point I had a choice: take an existing open-source model, fine-tune it, and build something around it — or go much deeper and try to create the model itself.
The sensible option would probably have been to start with an existing model. It would have been faster, easier, and far more practical. But I wanted to understand what was actually happening inside a language model, not just learn how to use one.
So I chose the harder route: build it from scratch.
That decision made the project dramatically more difficult. I had to learn concepts I had never worked with before and turn them into actual working code. Tokenization, embeddings, attention, Transformer blocks, model dimensions, training, data, checkpoints, inference — every part became something I had to understand rather than simply configure.
There were plenty of moments when I thought I had made the wrong decision. An existing model would have let me get to a working result much faster. Building from scratch meant constantly running into problems where I didn't even know what I didn't know.
It was horribly difficult. But that difficulty was also the point. Every time something finally worked, I understood a little more about why it worked.
Building toward Verse1 Uncensored
Eventually, I decided I wanted to stop only consuming AI and actually build a model myself.
That became Verse1 Uncensored.
The project grew into a from-scratch language-model effort: a custom tokenizer, a decoder-only Transformer architecture, training code, data preparation, experiments, and a chat interface. Instead of treating the model as a black box, I wanted to understand and control the pieces that make the system work.
There were plenty of moments where the code ran but the result was terrible. There were experiments that taught me what not to do. There were bugs that looked impossible until I found one tiny mistake. And there were times when I genuinely wondered whether I was trying to build something far beyond my current level.
Trial and error became the real teacher
The biggest lesson was that progress did not look like a straight line.
I would learn one concept, try it, get it wrong, search for an explanation, watch another video, change the implementation, run another experiment, and repeat. Slowly, things that once looked like complicated research papers started turning into engineering problems I could reason about.
I also learned that building something yourself gives you a different kind of understanding. When you have personally dealt with tokenization, model dimensions, training loops, checkpoints, inference, memory constraints, and debugging, the concepts stop being abstract vocabulary.
And then it finally worked
The best part was not a single line of code. It was seeing the pieces finally come together.
After a year of learning, experimenting, failing, rebuilding, and trying again, I had something I could point to and honestly say: I built this.
Verse1 Uncensored is not the biggest language model in the world, and I am not pretending that it is. What matters to me is what it represents. I went from connecting an API to a frontend to understanding and building the core pieces of a language model myself.
That gap is the real achievement.
What I learned from the year
If I could go back to the beginning, I would not tell myself to wait until I knew enough.
I would tell myself to start.
Start with the API. Build the simple frontend. Watch the tutorial. Get confused. Break the code. Ask questions. Read the documentation. Try again. Then go one level deeper.
You do not need to understand everything before you build. Sometimes building is how you finally understand.
This project started with curiosity, survived a lot of mistakes, and ended with something I am genuinely proud of.
What's next
Verse1 Uncensored is a milestone, not a finish line.
There is still a huge amount I want to learn about model architecture, training efficiency, evaluation, datasets, inference, deployment, and the wider AI ecosystem. I know there will be more bugs, more failed experiments, and more things I do not understand yet.
But that is exactly what makes the next year exciting.
A year ago, I was mostly connecting APIs to frontends.
Today, I can look at Verse1 Uncensored and know that the journey has moved much closer to the model itself.
And I am just getting started.