June 8
On June 8, 2025, a friend of mine wanted to build a website for his mum's catering business.
I volunteered to help.
There was only one problem:
I didn't know how to build a website.
We had another friend who said he knew coding, so we asked him what to do. He didn't know enough to take us very far either, so we started searching.
I downloaded VS Code.
We asked ChatGPT how to make the site, and it gave us some HTML.
I didn't just want the code.
I wanted to know what it was.
What is HTML?
Why is this tag here?
How do I see what I've written?
It told me about Live Server.
What's Live Server?
An extension.
I installed it.
Before even using it properly, I went into the folder and opened the HTML file myself.
The browser opened.
And there it was.
Something I had written was on the screen.
I still remember that feeling.
Then I tried Live Server.
This time the address looked different. Before, the browser showed me something beginning with "file://". Now I was looking at an IP address.
Why?
Another question.
Another answer.
Another thing to explore.
My friend eventually went to sleep.
I didn't.
By the time he woke up, I'd already made a basic landing page.
And I kept going.
How do websites get their own domains?
How do you put one on the internet?
How does Google know it exists?
I found InfinityFree. I learned how to upload the site and configure "starms-catering.rf.gd". I found Google Search Console. I learned about meta tags.
I discovered GitHub and did what I usually do when I find something new:
I clicked basically everything.
I didn't know Git yet, and I didn't even know how I was supposed to properly update the files I'd already uploaded. So my solution was to keep making repositories.
"starts catering"
"Starms V1"
"Starms V2"
"Starms V3"
"Starms V4"
Eventually I started wondering how people were actually editing projects without doing whatever this was. That question led me to Git.
I learned how to use it, and suddenly the five-repository versioning system was no longer necessary.
I became fascinated by the fact that Live Server was serving my files, so I wondered whether I could create a server myself.
That question led me to Python.
"python -m http.server"
And suddenly I was experimenting with servers too.
Between June 8 and June 22, I kept rebuilding that catering website while learning whatever I needed as I encountered it.
Then it was done.
I gave it to my friend to show his mum.
And when I searched for it on Google, it was there.
I had made something.
Not in my head.
Not something I was planning to start one day.
Something that existed.
And I wanted to know what else I could make.
How Do Chat Apps Work?
For a while after finishing the catering website, I went back to school and focused on my exams.
Then August came.
I was home again, and one question entered my head:
How do chat apps work?
So, as usual, I started asking questions.
I searched Google. I asked ChatGPT. Eventually, I got some code using WebSockets and started experimenting with it.
I got a basic chat working.
Then I deployed it on Vercel and tested it with my family.
Seeing messages appear between different devices felt completely different from building a static website. Someone could type something on one device, and another person somewhere else could receive it.
That was cool.
Very cool.
And, naturally, a basic experiment was no longer enough.
I wanted to rebuild it properly.
That was how I started learning Next.js.
I hadn't even learned React first. I went straight into Next.js 13 with the Pages Router and figured things out as I needed them.
Around the same time, I started properly learning Git.
My first experience with GitHub had basically been creating a new repository whenever I needed another version of the catering website. Now I was beginning to understand commits, branches, repositories and how I could actually track changes without creating V2, V3, V4 every time something changed.
A lot of that learning didn't come from tutorials.
I'd run commands with -h, look through the available options, try things, break things, ask questions, and figure out why something behaved the way it did.
That became a pattern.
I didn't learn something because it was next on a curriculum.
I learned it because something I was trying to build had put a wall in front of me.
The chat experiment kept growing.
Eventually, it became Steel.
I wanted more than a chat app. I started imagining something developers could use to communicate, write code, share things and eventually build together without constantly moving between different apps.
Once again, the world in my head was getting bigger.
Except this time, I was actually writing the code for it.
Can I Do This From My Phone?
The phone part of this story actually started earlier than people might expect.
Back in June, while learning HTML, CSS and JavaScript, I was already sending files to my phone so I could open them in the browser and see what I had built.
But in August, I started becoming curious about the connection itself.
If my laptop was running the website, could my phone access it?
That sent me further into networking.
IP addresses. Ports. Devices on the same network. Hosting something on one device and accessing it from another.
I was still mainly coding on my laptop, but I had started asking a more important question:
Could I actually code on my phone?
By September, I had installed Termux and started playing around with it.
At first, it was just another thing to explore.
I didn't know how important it was about to become.
Steel Was Taken
By then, Steel wasn't just the little WebSocket experiment anymore.
I'd kept building it through different versions, showing pieces to friends and family and imagining where I could take it.
Then I discovered a problem.
The name was already taken.
That hurt more than it probably should have.
I'd already attached a lot to the name. I'd even talked to my mum about where I wanted to take the project. I had ideas for the brand beyond the software itself.
I had also trusted ChatGPT when checking whether the name was available.
It had told me it was.
It wasn't.
A friend suggested another name: Cobase.
That sounded good too.
I checked again.
Taken.
Even the variations were taken.
At one point I'd considered turning Steel into a programming language, so after everything else I thought, let me check that too.
There was already a language called Steel.
That period taught me something simple:
If something matters, verify it yourself.
Eventually, Steel needed another name.
It became Biuld.
Yes, Biuld.
Not Build.
I kept going.
September 23
By September, I was deep into Biuld.
My laptop battery had already gone bad. It couldn't really survive away from power anymore, but for part of that period I was staying with my brother, and he usually had the generator running, so I could still sit down and code normally.
Then I decided I wanted to release Biuld as a desktop app.
That introduced me to another thing I'd never used before:
GitHub Actions.
I needed builds for Windows, Linux and macOS, so I made my first build matrix.
It did not work.
I changed something.
Ran it again.
It failed.
I opened the logs, tried to understand the error, changed something else and ran it again.
Another failure.
At some point I was tired of reading error logs. I had spent hours staring at them, trying one fix after another.
The workflow finally worked on the 79th run.
Seventy-nine.
But it worked.
And on September 23, 2025, I bought the domain and launched Biuld.
I showed my brother.
I posted it.
Something that had started with me asking how do chat apps work? now had a name, a domain and desktop builds for three operating systems.
The next day was September 24.
I turned 17.
When the Laptop Stopped Following Me
In October, I returned to school.
The laptop battery was still bad, except now I didn't have my brother's generator around me all the time.
So I started doing more of the work from my phone.
By then, I already had Termux. I'd already experimented with running things and accessing servers between my phone and laptop. Using the phone itself wasn't completely foreign anymore.
But continuing Biuld on it was different.
I could write the code.
Testing it was the problem.
Biuld was a desktop application. My phone couldn't simply run the thing I was building.
So I'd make changes, push them, let GitHub Actions build the desktop versions, and then I still needed an actual computer to know whether everything worked properly.
Sometimes I'd try to find someone with a laptop who could test a build for me.
But they had their own work to do too.
I couldn't keep depending on someone else being free every time I changed something.
Eventually, I stepped away from Biuld for a while.
It wasn't because I'd stopped caring about it.
At the time, I simply didn't have a good way to keep building and testing the kind of application I'd chosen to make.
I didn't know it then, but that limitation was going to push me much deeper into building from my phone.
And the project that finally did that wasn't Biuld.
It started when a friend told me he wanted to create a library for students.
Fuck It. Make the Phone Handle It.
In November, a friend told me he wanted to create a library for students.
A place where students could find notes, PDFs, past questions and other academic materials without having to keep asking around for them.
I liked the idea.
By then, I'd already experimented with tools like v0 and Lovable. I'd once tried using them to generate a crypto finance app, so I knew what they could do.
Or, more importantly, what they couldn't do.
Still, for this project I started with v0.
I wrote a prompt that was around 800 lines long.
Yes, 800.
I had ideas.
I borrowed my friend's laptop because, even though I'd already been coding from my phone, I wasn't convinced the phone could handle what I was about to build.
This wasn't a small HTML website anymore.
I was using Next.js 15. I was moving into the App Router. I needed authentication, a database, storage and a proper backend. I chose Supabase.
I called the project My Campus Library.
MCL.
The first result from v0 wasn't what I wanted.
That was when something I'd already been slowly learning became obvious again: AI could help me build, but it wasn't going to magically understand the complete thing inside my head and hand it back to me finished.
So I started recreating it myself.
At first, I had two repositories: the v0-generated version and my own.
I'd look at what v0 had done, take pieces that were useful, copy some boilerplate where it made sense, rewrite other parts and slowly build my own version around it.
There was still a problem.
The laptop wasn't mine.
My friend needed his computer too.
And I couldn't build an entire project around waiting for someone else's laptop to become available.
I'd already written code on my phone.
I'd already used Termux.
I'd already pushed changes, worked with Git and found strange ways around not having a functioning laptop.
But part of me still looked at a project like MCL and thought:
Surely I'm not going to build all of this on a phone.
Then eventually:
Fuck it. Make the phone handle it.
So I did.
Next.js ran on the phone.
Supabase didn't care what device I was using.
Git didn't care.
Vercel didn't care.
The browser didn't care.
If something assumed I was sitting in front of a normal development machine, I started looking for another way around it.
My phone stopped being the thing I used because my laptop wasn't working.
It became my development environment.
Building MCL
MCL taught me a lot because there was simply too much I didn't know.
The App Router was new to me.
Supabase was new to me.
Authentication was new to me.
Working properly with a database was new to me.
And as the project grew, the things I needed to understand grew with it.
I learned more about React because I actually needed it now. I learned how to handle dynamic routes, slugs and params. I experimented with dynamically generated Open Graph images. I built my first proper admin dashboard. I worked with proxies and started understanding more of what was actually happening between the browser, my application and everything behind it.
There were countless smaller things too—things I probably wouldn't remember to list now, but that I had to understand because at some point MCL refused to work without them.
So January became intense.
I would work on MCL, get stuck, search, ask questions, read documentation, change something, break something else, fix that, then continue.
I wasn't following a course.
There was no Week 1: Learn Next.js. Week 2: Learn databases.
There was just a project I wanted to exist and an endless series of things standing between me and the version of it I could see in my head.
Eventually, exam period came.
I launched MCL, but late enough into the exams that it didn't get the number of users I'd hoped for.
That hurt a little.
I'd spent so much time building it, and by the time students could properly use it, the period where they needed it most was already ending.
But MCL wasn't finished.
Neither was I.
And while I was building it, another curiosity had started pulling at me.
Rust.
I Don't Really Take Courses
There's something I should probably explain here.
I've never really learned programming by taking programming courses.
Not one full course.
I tried.
At one point in 2025, I'd been introduced to a group of people on X doing a 365-day building challenge. We eventually split into smaller groups to build products and test our skills.
The developer I was paired with told me he was learning Node.js from YouTube and sent me the course.
I opened it.
I watched for about 13 minutes.
And left.
It wasn't even that the course was bad.
Learning that way was just stressful for me.
The way I seem to learn is backwards.
I start with something I want to make.
Then I discover that making it requires something I don't know.
So I learn that thing.
Then that exposes something else I don't know.
So I learn that too.
And I keep going until either the thing works, I abandon it, or I accidentally find another thing I want to build.
Rust wasn't going to be any different.
Before Portal, There Was Tshare
Before I started learning Rust, I had a small private tool called Tshare.
It was written in Python.
I wanted a fast way to move files between my phone and other devices, especially from the terminal.
Tshare was simple.
I'd put it on my phone and on my friend's laptop. When I wanted to share files, I'd run server.py, the other device would connect through my IP address, see the files and download what it needed.
For us, it worked.
But I couldn't really give Tshare to everybody.
The way I'd built it assumed trust.
If I gave someone the source code and let them run it against my files, there wasn't a proper permission system making sure they could only take what I actually intended to send.
That bothered me.
I wanted the speed and simplicity of transferring files from the terminal without exposing everything behind it.
So the question changed.
How do I turn this little private Python tool into something I could actually give other people?
That question became Portal.
And for Portal, I decided to use Rust.
I didn't learn Rust and then look for a project to practise with.
I started Portal.
Then I learned the Rust I needed to make Portal work.
Read.
Build.
Error.
Search.
Fix.
Continue.
It was the same pattern again.
Only now the things I was trying to build were getting harder.
No comments yet