It started with a phone.

It started with a phone.

I didn't begin with a computer science roadmap, a powerful development setup, or even a clear idea of what I wanted to build.

I started by making small static HTML websites and hosting them from my phone. Seeing something I'd made become accessible on the internet for the first time was enough to make me curious:

That curiosity eventually led me to Python.

I didn't know the whole language—and I still wasn't writing everything from scratch. I used AI heavily, understood enough of the code to experiment with it, broke things constantly, and gradually learned by trying to make ideas actually work.

And that's where things started getting interesting.

There was another part of this that shaped almost everything I built afterwards:

And it wasn't some unusually powerful phone either. I was using an OPPO A15, a fairly average Android phone.

I just didn't want to give myself the excuse that I needed a laptop before I could start coding or making projects.

So whenever my phone couldn't do something, I looked for a workaround.

For simple scripts, I used Termux.

For things that needed a GPU, I used Google Colab or Kaggle.

If I couldn't comfortably manage and run a modern web project locally, I used AI agents that had their own computers.

Later, when I started working on Android apps and couldn't use Android Studio on my phone, I used GitHub Actions to compile the APK remotely.

I didn't have the ideal development environment.

So I slowly built my own development environment out of whatever was available on the internet.

I discovered APIs, then found Groq, and decided to build a chatbot.

I called it Kia.

Its system prompt was almost embarrassingly simple:

That was basically it.

But seeing a chatbot I'd made respond to me for the first time was enough.

Then I noticed something annoying.

Kia had the memory of a goldfish.

I could tell it something, send another message, and it behaved like the previous conversation had never happened.

At first, I thought this was something the AI or API was supposed to handle automatically.

It wasn't.

While trying to fix it, I learned that my own program had to keep the previous messages and send that conversation history back to the model whenever I wanted it to remember what we'd been talking about.

That was my introduction to conversation memory.

It was one of the first times a bug taught me more than a tutorial could.

Eventually Kia could actually hold a conversation.

Naturally, my next thought was:

That sent me down another rabbit hole—Telegram's Bot API, hosting platforms, PythonAnywhere, webhooks and increasingly complicated bot logic.

Generating correct working code with AI was a headache, but eventually Kia escaped Termux on my phone and became an actual Telegram bot I could message from anywhere.

And while messing around with it, I discovered something that changed the direction of my experiments completely:

And then my mind immediately went somewhere it probably shouldn't have.

Until then, Kia's system prompt basically said:

"You're Kia. You're friendly."

But the more I experimented, the more I realized that a system prompt could shape much more than a chatbot's name.

I could tell the AI who it was supposed to be, how it should behave, and what kind of conversation it was supposed to have.

And, naturally, the first question that came into my head was:

There was only one reasonable way to answer that.

I built one.

I called it DreamKia.

Instead of Kia's tiny "friendly virtual assistant" instruction, DreamKia had a much stronger character and roleplay-oriented prompt.

Same basic idea of talking to an AI.

Completely different experience.

And it worked surprisingly well.

That fascinated me.

I hadn't trained anything.

I hadn't modified the underlying model.

I'd mostly changed the instructions surrounding it, yet it behaved like an entirely different character.

For a while, I just experimented with that.

Then, as usually happens with my projects, I got another idea.

Text was starting to feel boring.

What if DreamKia could actually generate what was happening?

Around that time, I discovered SDXL.

It could generate images from text.

So the obvious thing would have been to add an image command to DreamKia:

But I didn't like that.

Imagine you've already been talking to a character for several messages.

The conversation already contains the setting and what's currently happening.

Then suddenly the bot asks you:

Why?

We literally just spent ten messages describing it.

So I tried something else.

When DreamKia needed to generate an image, my script would take some of the recent messages from the conversation—both what the user had said and what DreamKia had replied.

That gave it the recent context.

From that context, the system could figure out what kind of scene matched the conversation and turn it into a prompt that SDXL could understand.

Then SDXL generated the image.

And the bot sent it straight back into the same Telegram chat.

So from the user's perspective, there wasn't really:

a chatbot

and

an image generator.

You just talked to DreamKia.

And when an image was generated, it actually matched the context of the conversation instead of making you explain everything again from scratch.

And somehow...

it worked ridiculously well.

I shared DreamKia with some friends.

They loved messing around with it too.

I wasn't thinking:

"Today I will study multimodal AI architecture."

💀

I basically thought:

"Can I make an AI do spicy roleplay?"

conversation memory,

character behavior,

system prompts,

image-generation models,

passing context between different AI systems,

and making multiple models feel like one product.

My first chatbot was basically:

DreamKia was the first time I started stitching different pieces together to create an experience that none of those pieces could provide alone.

My father runs a shop where one of the things he does is prepare and print passport-size photographs.

He used an AI tool to improve faces in photos.

Then it became paid.

So I thought:

That question became one of the most important projects I've made.

I found CodeFormer and started experimenting with image-restoration APIs. But simply enhancing an image wasn't enough.

I wanted to automate more of the workflow.

So I built a Telegram bot that could take an uploaded photograph and process it through a pipeline:

Upload → Enhance → Remove background → Make it white → Generate a print-ready sheet of passport photos

The interesting part was how I built it.

Different pieces were generated and debugged with different AI systems. I worked on each part separately and eventually connected everything into a single working pipeline.

And it worked.

Then the API credits ran out.

That could have been the end of it.

Instead, I started looking for another way.

I discovered that the model had a Hugging Face Space that, at the time, could be used freely. Getting my own program to reliably interact with it became an unexpectedly difficult problem.

It took weeks of experimenting with AI-generated code, debugging and trying different approaches before I finally had a working solution.

And suddenly I had something I'd originally built for one person that could process images without the API limitation I'd started with.

Then something unexpected happened.

Other people found the Telegram bot.

No advertising.

No subscription.

No launch campaign.

According to my bot's usage data, it eventually reached 1000+ users outside my father's use.

That was probably the first time one of my experiments stopped feeling like an experiment.

Eventually I wondered:

I used Manus AI to help create a web version and continued developing it from there.

It's free, publicly accessible, and still being used by real people.

What started as:

eventually became:

That's probably the best explanation of why I like building things.

Then I kept experimenting.

Not everything needed to become a startup.

Sometimes I built things simply because the technology sounded fun.

After discovering AI voice conversion through YouTube, I started experimenting in Google Colab with converting voices and generating songs using my own and my friends' voices.

It wasn't particularly useful.

It was extremely fun.

And it introduced me to another completely different area of AI.

And after spending so much time making existing models behave differently, another question eventually appeared:

What if I stopped changing someone else's model with prompts...

...and actually trained one myself?

That question led to one of the strangest things I've built.

Eventually, after stitching memory, system prompts, and image generation into DreamKia, another question appeared:

I started learning about model training, choosing a base model, preparing conversational data and concepts such as epochs and training loss.

For the dataset, I collected examples from my own conversations and experimented with training a model around those communication patterns.

It wasn't something I needed.

I built it because I wanted to know whether I could.

And that describes quite a few things I've made.

After we got a smart set-top box, I ran into an incredibly ordinary problem.

I had found various websites for discovering movies and anime, but repeatedly typing URLs with a television remote was miserable.

So instead of continuing to type them...

A simple website that organized the destinations I wanted into one place.

Open StreamPoint → choose where I want to go → done.

I shared it with friends who watch movies and anime, and they started using it too.

Later, one of them casually told me:

That tiny sentence meant more to me than a page-view counter.

He didn't call it "that website you made."

He called it by its name.

It had become a product in someone else's mind.

Then I tried to fix one of my own biggest problems.

By this point, AI had made it possible for me to build things that would have been far beyond my coding knowledge otherwise.

But developing from a phone still had an annoying workflow.

I could ask an AI to generate some code, but then I'd have to copy it, move to an editor, paste it, test it, return to the AI, explain what happened, get another version and repeat.

There were plenty of code editors for Android.

There were plenty of AI coding tools.

But I couldn't find an Android code editor that had the kind of deep AI integration I wanted—especially smart inline suggestions and the ability to actually write and work with code directly inside the editor.

So eventually I thought:

Instead of having AI as a separate chatbot that happens to know programming, I wanted it integrated directly into the editor.

So PocketDev gradually gained things like:

smart next-line AI suggestions,

writing code with AI,

finding bugs with AI,

explaining code,

automatic debugging,

and a system that could attempt to fix code, run it again, inspect what went wrong and continue trying until it ran successfully.

One of my favorite parts became the autocomplete interaction.

If I simply continue typing, the suggestion disappears.

And for multiline suggestions, I can partially swipe to accept only one line and continue from there.

I can't claim that interaction as an original idea.

I first saw something similar while writing an email in Gmail. It predicted the rest of a sentence and told me to swipe right to accept it.

I liked the interaction so much that I thought:

I think being honest about where an idea came from is much more interesting than pretending I invented everything myself.

But it's not perfect.

Larger files can still cause performance problems. The editor itself needs optimization. The way project files and context are provided to AI could be much better.

I've considered using an open-source editor such as Sora Editor, but integrating it into what I'd already built while preserving the AI features and autocomplete turned out to be much harder than simply replacing one component.

My current implementation is closer to a heavily extended text editor than the Android equivalent of a full desktop IDE.

I can't open Android Studio, modify something and immediately look at the result.

Sometimes I know exactly what tiny change I want.

Maybe I just want:

5px of padding → 10px.

I could make that change myself.

But I can't conveniently load, edit, compile and preview the Android project locally.

So the workflow can become:

change code → push to GitHub → GitHub Actions compiles APK → download/install build → open it → inspect the change → repeat

Sometimes an entire APK has to be compiled just so I can find out whether a tiny UI adjustment looks right.

It's frustrating.

But there's something strangely appropriate about it too.

It still has a lot to improve.

That's part of why I'm still interested in it.

There's another thing about the way I build that probably sounds strange at first.

If AI gives me a piece of code, I test it, and it works correctly, I don't necessarily start asking:

"Explain this function."

"Explain that class."

"Explain exactly how every part works."

It's not because I think understanding code is unimportant.

It's because when I'm actively building something, the AI's context window is part of my development environment.

Sometimes I've spent a long conversation getting the model to understand exactly what a feature is supposed to do, how the existing code is structured and what problems we've already solved.

If I then fill that conversation with explanations of things I don't currently need, eventually the earlier context starts disappearing.

And if I later need to change the feature, the AI may no longer remember why the code was written that way in the first place.

So I tend to learn things when they become relevant to what I'm changing or debugging.

It's certainly not a perfect workflow.

It also means there are times when I'm dependent on AI for modifications I could probably make much faster myself if I had a normal development setup and deeper knowledge of the codebase.

I don't really want to hide that.

Eventually, if I was going to put all these things under one identity, I needed something that represented me.

So I made the LSGZ logo.

It didn't start with an AI image generator.

It started with pen and paper.

I drew the original idea myself, then later used AI to help polish and refine it digitally while keeping the identity of the original drawing.

I like that little detail because, in a way, it's exactly how I've built most of my projects.

The idea starts with me.

The first version is usually imperfect.

AI helps me push it much further.

Then I keep changing things until they feel like mine.

And eventually, I needed somewhere to put all of this.

After finishing Class 12 and preparing to begin B.Tech IT, I decided it was finally time to build a proper portfolio.

Not a page containing my name, three progress bars and a list of programming languages.

I wanted somewhere that actually represented the things I'd been making.

So, like most of my projects, I kept iterating.

Different AI systems helped with different pieces. I changed layouts, threw things away, rebuilt sections, obsessed over tiny details and kept polishing until the website started feeling like mine.

There wasn't one prompt that produced it.

There wasn't one AI that built it.

It slowly came together through different tools, different models, experiments, mistakes and a lot of tiny decisions.

Even my logo—the symbol sitting above all of it—started as something I drew on a piece of paper.

And that's the website you're reading now.

Then I actually joined college.

And almost immediately, one thing annoyed me.

Wanting to know my own timetable meant opening the college website, finding my branch, then my section, then the day, then the time. Every morning. No app, no reminder, just four clicks I had to remember myself.

Then I noticed something else.

I kept forgetting to check it.

Four days into college, I found out how badly.

I was bored in one lecture — properly bored — and by the time it ended I'd already checked out in my head. I packed my bag and went home.

Then it hit me.

I'd completely forgotten it existed.

So I decided that if the website wasn't going to remind me, I'd build something that would.

I found out later that the lecture I thought I'd skipped had actually been cancelled that day. There was nothing to miss.

It didn't matter. I kept building it anyway.

It slowly turned into something real: a live "what's next" card, offline reminders that fire without needing the internet, attendance tracking, old papers — everything those four clicks never gave me.

Somewhere along the way I made it pull a student's info straight from the college site, mostly so I could check my own registration number without opening the portal.

I was doing exactly that in class one day when the guy behind me leaned over.

He tried it. Told a friend. That friend told another.

No ads. No launch post. Just someone behind me, curious about my own registration number.

Four days into college. I didn't know most of my classmates' names yet, and some of them were already using something I'd built.

I don't really have a traditional development story.

I didn't learn everything first and then start building.

I did almost the opposite.

I wanted something → tried to build it → got stuck → learned what I needed → got it working → found another problem.

AI has been part of that process from the beginning.

I don't pretend I manually wrote every line of code. I use AI aggressively—as a coding tool, debugger, researcher, designer and sometimes as a way of understanding technology I haven't encountered before.

But deciding what should exist, connecting the pieces, dealing with things when they don't work, refining the experience and deciding when something is finally worth shipping—that part is mine.

And doing all of this from a phone has forced me to get comfortable with another part of building:

Can't run something locally?

Find somewhere that can.

Need a GPU?

Use Colab or Kaggle.

Can't use Android Studio?

Compile remotely with GitHub Actions.

An API becomes paid?

Find another approach.

The tool I want doesn't exist on Android?

Try building it.

I didn't decide at the beginning that this would be some kind of philosophy.

It just became the way I worked.

And somehow, a journey that started with a few static HTML pages hosted from a phone turned into bots, AI experiments, trained models, an Android code editor and products used by people I've never met.