Vibe coded Portfolio link : https://www.harshithdeshalliravi.us/

Alright, so picture this: I’ve been deep in the coding trenches for a while, mostly navigating the backend labyrinth — that’s my zone. But throw me into the world of frontend design? Making webpages pop with slick interactions and dynamic bits? Yeah, total blank slate. Felt like trying to speak a language I’d only heard whispers of.

Then came the AI wave. Like everyone else, I’ve been totally hooked, playing with pretty much every new AI gadget that dropped over the last couple of years. It’s been wild watching it all unfold.

That’s when this whole “vibe coding” thing started buzzing. Seeing folks, some who barely code, just manifesting apps? Even building legit businesses pulling in serious cash? It felt… different. Like tapping into some kind of creative flow state with the machine. I had to feel it out for myself.

So, I dove in. Tried jamming with tools like bolt.new, messing with cline on VS Code, tinkering with lovable… but honestly? The vibe just wasn’t right. Felt clunky, couldn’t get the look or the backend hooks quite how I pictured them. My flow kept getting blocked.

Just when I was about ready to shelve the idea, I caught the Firebase Studio release. Okay, I thought, this feels different. A little spark ignited — maybe this whole vibe coding thing could actually work for building something real.

That lit the fire. I decided to just go for it, set myself a wild challenge: build an entire web app purely by vibing with AI. No safety net, zero lines of my own code. And honestly? Spoiler alert: The results kinda blew my mind. What emerged was way closer to my vision than I’d dared to hope.

So, what project to tackle? After bouncing a few ideas around, it clicked: why not just vibe out my own portfolio site? Perfect playground.

Going into Firebase Studio, I kept my expectations chill — figured maybe I’d get a basic structure, something functional even if it wasn’t a design masterpiece. But once I started prompting, riffing, chatting with the AI… my hopes shot up. Still, part of me wondered if it would just plateau, you know? Like the AI would run out of creative juice after a few rounds. Oh, and apparently, I’d jumped into some timed thing — a 3-hour clock started ticking to pull the whole project together. Talk about diving headfirst into the vibe!

So, let’s unpack those 7 hours. Stepping into this, you definitely feel that weird energy shift, right? That whole “Is AI gonna just… do our jobs?” buzz. It’s less about erasing humans and maybe more like… whoa, the definition of ‘coding’ is getting seriously remixed right in front of us.

Firebase Studio wanted the grand vision first. So, I basically dumped my brain into the prompt — a full 150-word download of every feature, every little interaction I was picturing for the portfolio. It chewed on that, spit out an initial game plan. We riffed on it a bit, tweaked the flow, got in sync. Then, the AI started cooking. Took a solid 10 minutes — felt longer, watching the virtual gears whir, dependencies installing — to spin up the environment and lay down the first batch of code.

And honestly? That first “zero shot” reveal was kind of electric. Even though the look wasn’t quite my style yet, the way it interpreted the core idea? The underlying structure? It got it. That initial spark was all I needed. It felt less like giving instructions and more like starting a jam session.

“Okay, cool start,” I prompted, “but let’s change the whole vibe here. Rework the skeleton, shift the design language.” And it listened. The iterations started flowing, and I began genuinely digging the aesthetics it was proposing. That planned 3-hour sprint? Totally forgotten. I was locked in, pushing the session to 7 hours (with a couple of sanity breaks).

This wasn’t just about painting by numbers, either. We were debugging on the fly, adding features as ideas popped up, swapping out designs. I threw it a curveball: “Go scrape my details from GitHub and LinkedIn and weave them into these pages.” And it just… did it. Pretty smoothly, too. Then came the mobile check — always the moment of truth. Looked wonky. A quick prompt later? Bam. Fixed it clean, responsive, like a seasoned pro nailing a media query first try. That feeling? Pure collaborative magic.

Now, it wasn’t all smooth sailing and pixel perfection. Getting the background design just right? Man, that was a struggle. My prompts felt like they were hitting a wall; the AI’s interpretation just wasn’t vibing. Felt like we were out of sync. Then, the breakthrough: instead of trying to describe the feeling I wanted, I just described the visuals I needed. Gave it the ‘what’. With that clarity? It coded the algorithm like snapping its fingers. Piece of cake. Sometimes, you gotta switch up how you communicate with your digital dance partner.

And yeah, let’s be real — it’s beta software. The flow definitely got disrupted. The session just blinked out a couple of times, forcing a VM restart. Happened three times during the 7 hours. Talk about a vibe killer! Super frustrating when you’re deep in the zone.

But one massive win? Built-in Git. When a few of my experimental prompts led down a weird path (happens!), rolling back was painless. Having that version control safety net? Absolutely crucial when you’re surfing the vibe and trying wild stuff. It lets you explore without consequence.

So yeah, from “AI replacing humans” to maybe… “AI augmenting humans”? It felt less like replacement and more like having this incredibly fast, sometimes quirky, but ultimately powerful coding partner riding shotgun.

So, wrapping this all up? Honestly, I walked away seriously impressed. This whole vibe coding journey, especially jamming with Firebase Studio, was way more powerful than I expected. It shifted my whole perspective — it’s less about AI taking over and more about finding new ways to flow, to create, to bring ideas to life faster and maybe even more intuitively than before.

If you’ve been curious about this stuff, or if you’re like me and frontend sometimes feels like a different galaxy, I genuinely think you should give it a spin. Just dive in, throw some ideas at it, and see what kind of magic you can conjure up together. You might surprise yourself.

Wanna see how my 7-hour AI jam session turned out? Check out the final result below!

My Vibe-Coded Portfolio: https://www.harshithdeshalliravi.us/

Happy coding, don’t forget to clap and follow for similar content.

As a self-proclaimed tech freak, I’ve always dreamed of running an LLM (Large Language Model) locally on my phone. Why? Because while I love tinkering with AI and use Ollama Server on my workstation, I’m also deeply concerned about privacy when using proprietary models from OpenAI, Claude, and Google. Plus, let’s face it — lugging around a laptop everywhere isn’t always practical. And when I’m out and about, my options for using AI locally shrink faster than my phone’s battery.

Luckily, with SLM (Small Language Models) improving every day, we can finally take advantage of their efficiency to run AI directly on our phones. No cloud, no data leakage — just pure, unadulterated AI goodness in our pockets.

Why Would You Even Need AI on Your Phone?

Some of you might be thinking, “Why bother? I have the internet!” But there are actually plenty of scenarios where a local AI model on your phone could be a game-changer. Let’s go through a few:

1. Survival Mode: AI in the Wild

Picture this: You’re camping deep in the forest, and suddenly, you need to write a poem about the beauty of nature. No Wi-Fi, no internet, but thankfully, you’ve got your trusty LLM running locally. Okay, maybe you need it for something more practical — like translating survival guides, generating emergency messages, or even debugging your own thoughts when lost in the wilderness.

2. Privacy: Because Even Apple Has Trust Issues

Sure, Apple claims to be the champion of privacy, but let’s be real — there have been plenty of allegations against them regarding data security. So, why entrust your sensitive data to any big tech company? Running a local AI model means you can draft emails, compose urgent formal messages, or even polish your grammar — all without your data ever leaving your device. AI-assisted writing without the prying eyes? Yes, please!

How to Set Up an LLM on Your Android Phone

iPhone users, sorry, you have no option other than trusting Apple.

Installation Guide

1. Install Termux Application

There are two ways to install it. If the first method works, don’t bother with the second one.

• Method 1: Download directly from the Play Store and move to second step.
• Method 2: If the application is not listed in your country, follow these steps:

Go to the Termux GitHub releases page and download termux-app_v0.119.0-beta.1+apt-android-7-github-debug_arm64-v8a.apk and install it.

2. Install Requirements Before Running Ollama Server

After launching Termux, you’ll see a terminal that looks just like a Linux terminal (don’t feel like a hacker yet — four years ago, I downloaded it and felt the same way 😁). Follow these steps to set up the environment for Ollama:

• Grant Storage Access:

termux-setup-storage

This command will allow Termux to access your Android storage system. Once you run it, the Settings application will pop up. Scroll down, find Termux, and grant storage permission.

• Update Packages:

Before running or installing any tools, update the packages — just like you would on Linux:

pkg upgrade

Enter Y when prompted.

• Install Tools Like Git, CMake, and Golang:

These packages are required for downloading and building Ollama:

pkg install git cmake golang

3. Install and build Ollama:

• Clone the Ollama github repository

If you’re maintaining Termux daily, move to the folder where you want to install it. Otherwise, you can follow the steps directly.

git clone --depth 1 https://github.com/ollama/ollama.git

• Navigate to ollama directory:

After downloading move to ollama directory.

cd ollama

• Generate Go code and build ollama with it:

go generate ./..

go build .

This step may take some time, so patience is key. Once completed, congratulations — you have successfully installed Ollama on your phone!

4. Run DeepSeek Model or Any Other 1B or 2B Parameter Model

Now, let’s see how to download and run the DeepSeek model.

• Choose a Model:

Note: Models with more than 3B parameters can’t be run on a phone because they are too slow, and some can’t even be loaded into your VRAM.

Choose a model from the Ollama models library website. Look for SLMs (Small Language Models with fewer parameters). If you find one, you’re good to go.

There you will find the copy button as shown above. If you’re on a phone, select desktop view to see the copy button. Copy it.

• Download and Run Model:

For now, I will show how to run the DeepSeek 1.5B model, but you can select whichever model you want. Just make sure to follow these steps.

For DeepSeek model:

./ollama run deepseek-r1:1.5b --verbose

For your own model:

./<copied text from ollama webpage>

Here, the --verbose flag is optional and provides logs while you're running models. This command will start downloading the model to your phone—be patient! The time it takes depends on your internet speed. (If you're using mobile data, make sure you have at least 1.5GB of data remaining!)

Once it’s downloaded, you will see the interaction panel on Termux itself, where you can use the LLM model just like you would on a PC. But don’t expect performance like ChatGPT — after all, you’re running it on a phone with a small model, and it will take time.

Once again Congratulations on successfully installing and running llm model on your phone.

5. Managing Performance

While testing the DeepSeek 1.5B model on my Samsung Flip 5, I got a speed of 9 tokens per second. If you’re running a bigger model, your phone may hang — so stick to small models. And if you have a better processor than mine, you can expect more responsiveness.

6. Revisit the Model

Once you’re done using your model, close the Termux application and make sure to terminate it from your notification panel. Otherwise, it will keep running in the background.

To use it again, open Termux and run these commands (don’t worry, it hardly takes seconds):

cd ollama

./ollama run deepseek-r1:1.5b --verbose

These two commands will navigate and load the model to use.

7. Optional Cleanup

After using Ollama, you may want to clean up. This step is completely optional.

Remove Unnecessary Files:

chmod -R 700 ~/go

rm -r ~/go

The Future is Local (and Pocket-Sized)

With AI models getting smaller and more efficient, the dream of having a personal AI assistant running locally on our phones is becoming more of a reality. Whether for survival, privacy, or just nerding out, the ability to run LLMs on mobile devices opens up a world of possibilities. So, here’s to the future — one where AI fits in our pockets, respects our privacy, and doesn’t require us to sign away our souls in a terms-of-service agreement.

Happy coding, don’t forget to clap and follow for similar content.

I was surprised when I saw the benchmarks of DeepSeek R1 release open-source LLM models. I thought, ‘I want to try this out locally,’ so I downloaded it from the Ollama official website.

I started with the 1.5B parameter model. After trying it, I felt it was worse than other models of the same size. At first, I thought I might have made a mistake while downloading the model, but then I realized it was a quantized Q4_K_M model. Despite this, its performance was so poor that it couldn’t be used effectively.

After that, I tried models with different parameter sizes, and some of them were usable and even performed well. However, the first model I downloaded was far worse and not even close to the performance of other distilled models. I’ll try to highlight the numerous issues with the first model.

Problem 1:

It often hallucinates even when solving smaller math questions. I tested it with numerous questions, but the answers it produced after processing were consistently different from the expected results. Despite taking time to ‘think,’ the model frequently arrived at incorrect or nonsensical conclusions, highlighting its unreliability in handling even basic mathematical tasks.

Problem 2:

The model takes a significant amount of time to process questions, often asking nonsensical follow-up questions and eventually providing hallucinated responses. For example, I asked, ‘Which is bigger 5⁹⁹ or 99!?’ The model took 2.5 minutes to respond, even with an inference speed of 100 tokens per second. Despite the lengthy processing time, its answer was ‘5,’ which is blatantly incorrect. I tested it with various other math questions, and it exhibited similar behavior — delivering wrong answers after an unnecessarily long thought process. This not only highlights its inefficiency but also its lack of accuracy in basic problem-solving tasks.

Problem 3:

It’s too sensitive to questions related to individuals, countries, or the economy. It doesn’t even answer general questions like geographical ones. For example, it refuses to provide the capital of China. I found this model to be overly restrictive.

Problem 4: (major issue)

After one deep-thinking process, it sometimes becomes so hallucinated that it continues to answer any future questions with the same answer in that chat. Additionally, it occasionally changes its language to Chinese or another language, and once this happens, all subsequent answers are provided in the same language.

Problem 5:

If you use bad words in the chat, it changes to a different language and continues to answer in that language.

If you want to test this model, you can download it from this link — ollama

or run the following command in your terminal:

ollama run deepseek-r1:1.5b

Conclusion:

Among all of DeepSeek’s reasoning models, most perform well, delivering reliable results across various tasks. However, this particular model is broken and fails to meet basic expectations. Its performance is significantly worse than the similar-parameter model, DeepSeek R1-Distill-Qwen1.5b, which outperforms it in both accuracy and reliability. Overall, this model does not live up to the standard set by its counterparts and should be approached with caution.

Happy coding, don’t forget to clap and follow for similar content.

As a Data Science student, I have been working with CUDA for years, but I feel frustrated every time I try to install it. You see, we typically use TensorFlow or PyTorch, depending on our project’s purpose. However, the developers of these libraries can be quite cruel to us because they often don’t support the same CUDA version.

So I researched is there any way to resolve this issue, and I found solution is containerization via docker. There are images easy to install to any operating system with Docker using just one command in your terminal.

Docker run -it <image_name>

Although I have used Docker for several projects, I didn’t know it was possible to do that. Let’s set these things aside. Now, in this article, I will demonstrate how to build and run a container with Nvidia GPU CUDA support.

First, you need to have Docker on your computer or laptop. You can follow these steps if you haven’t installed it yet. If you’ve already installed Docker on your system, skip this part.

Docker installation

1. For Linux users (actual developers)

• Follow steps from this article — link

2. For Windows users

• Typically, Docker usually work with linux operating system, to support windows the developers have found workaround by utilizing WSL (Windows Subsystem for Linux).
• Follow steps from this article — link

3. For Mac users

• Only you have Nvidia GPU.
• Follow steps from this article — link

If you are facing any issues, look out for documentation from docker official blog page.

Note:

There are several points to note before following these steps:

1. Make sure you have sufficient storage left on your system, as these images are huge.
2. Docker is computationally intensive, so ensure you have enough computing power. This means your system should not be as old as you are.
3. One more thing: be sure you have an NVIDIA GPU, because CUDA only supports NVIDIA GTX and RTX GPUs.

Docker Image installation

Docker has several images for both Tensorflow and Pytorch with CUDA support. Before selecting an image, go to any LLM model (chatbot like chatgpt) and ask the following query.

I have <Your_gpu_name>, which <tensorflow or pytorch>, cuda and cudnn are  compatible with this GPU?

It will give you which TensorFlow/Pytorch is compatible with your system.

Before proceeding, ensure that you update your GPU drivers.

Now, go to dockerhub and search for image which has tensorflow or Pytorch and cuda support.

For Tensorflow:

Go to the TensorFlow/TensorFlow Docker Hub page and select your TensorFlow version. Then, look for the GPU option.

Or search below query in docker hub.

tensorflow/tensorflow:2.10.1-gpu

Search for the above image on Docker Hub. Make sure to replace it with your version.

For Tensorflow-jupyter:

If you’re a Data Scientist like me, you usually work with Jupyter Notebook. Don’t worry, Docker has you covered there as well.

Go to TensorFlow/TensorFlow Docker Hub page and select your TensorFlow version. Then, look for the GPU option and jupyter.

Or search below query in docker hub.

tensorflow/tensorflow:2.10.0-gpu-jupyter

Search for the above image on Docker Hub. Make sure to replace it with your version.

Copy entire image name, come back to your terminal and run the below

docker pull <your_image_name>

For Pytorch:

Go to the Pytorch/Pytorch Docker Hub page and select your Pytorch version. Then, look for your system supported cuda and cudnn version.

Copy entire image name, come back to your terminal and run the below

docker pull <your_image_name>

For pytorch-jupyter:

Go to Pytorch/Pytorch Docker Hub page and select your TensorFlow version. Then, look for your system supported cuda and cudnn version with jupyter.

Copy entire image name, come back to your terminal and run the below

docker pull <your_image_name>

This method is more flexible than installing CUDA on your host machine because it is not necessary to uninstall and install different versions for different projects’ requirements.

If you enjoyed reading, be sure to give it 50 claps! Follow and don’t miss out on any of my future posts — subscribe to my profile for must-read blog updates!

Thanks for reading!

Happy coding, don’t forget to clap and follow for similar content.