Forem: Tarun Kumar

Meet the Future on Four Legs: Why the Unitree Go2 Is More Than Just a Robot Dog

Tarun Kumar — Tue, 24 Feb 2026 04:54:07 +0000

I still remember the first time I saw a robot dog move in real life. Not in a YouTube video, not in a tech demo reel in person. And honestly? It stopped me in my tracks.
Robotics isn't something that lives in factories and research papers anymore. It's spilling out into parks, classrooms, construction sites, and yes, sometimes even living rooms. And one of the machines leading that charge is the Unitree Go2.
But here's the thing nobody tells you before you see it:
It doesn't look like the future. It moves like it.

It Starts with a Double-Take

At first glance, the Go2 looks like a sleek mechanical pet. Maybe something a tech company threw together for a trade show demo. You half-expect it to tip over or freeze up the moment it hits uneven ground.
Then it starts moving.
It doesn't shuffle. It doesn't stumble. It navigates. It reads the terrain beneath it, adjusts its stride mid-step, sidesteps obstacles without hesitation, and carries itself with this quiet, almost unsettling confidence.
That's when your brain shifts gears.
You stop thinking "cool gadget” and start thinking "wait, what exactly am I looking at?"
What you're looking at is embodied AI. Intelligence that doesn't just process it moves.

The Part That Actually Surprised Me

For the longest time, robotic dogs felt like a punchline or a pipe dream. Either absurdly expensive, locked inside a research lab somewhere, or just... not quite there yet. The kind of thing you'd see in a Boston Dynamics video and think "neat, but that's not for anyone like me."
The Go2 quietly changes that story.
Unitree built this robot to be agile, intelligent, and here's the detail that genuinely surprised me: accessible. Not "accessible for a Fortune 500 R&D department." Accessible for developers, educators, startups, and curious people who just want to build something real and see what happens.
In a field that's been gated behind million-dollar budgets for decades, that's not a small thing. That's a shift.

It Doesn't Just See It Understands Space

The Go2 uses a 4D ultra-wide LiDAR system, and if that sounds like dense technical jargon, let me translate it into something that actually matters:
This robot doesn't experience the world as a camera does. It doesn't take flat pictures and tries to guess what's in front of it. It builds a living, constantly-updating map of everything around its depth, distance, obstacles, and terrain.
That's how it avoids walking into things. That's how it plans its own path. That's how it handles the kind of messy, unpredictable real-world environments that make most robots look clumsy and confused.
In plain terms, it reads the room. And then it decides what to do about it.

The Movement Is the Thing

I can describe the specs all day. But honestly, the hardest part of writing about the Go2 is capturing what it feels like to watch it move.
It runs. It turns sharp corners. It climbs over small obstacles. When the ground shifts under it, it doesn't fall; it adjusts, recalibrates, and keeps going. The motor control and AI running underneath are doing an enormous, invisible amount of work to make all of that look completely effortless.
At some point, you stop seeing machinery.
You start seeing something closer to a new kind of creature, one that was designed, not born, but moves as it learned.

Here's What Most People Miss

A lot of people see the Go2 and think: finished product. Something you buy, watch do tricks, put on a shelf.
That's not what this is.
The Go2 is a platform. A starting point. Researchers use it to test real-world navigation models. Universities run experiments through it. Developers wire in their own algorithms and push the edges of what autonomous systems can actually do when they have a body.
Some models support 4G connectivity. Over-the-air updates mean the robot improves continuously. You buy it once, and it keeps getting smarter. The hardware you bring home today isn't the ceiling. It's the floor.
That's a fundamentally different relationship with technology than we're used to.

Why This Moment Actually Matters

We're at a strange, fascinating inflection point.
AI has spent years living on screens answering questions, writing text, and analyzing data. Useful, yes. Impressive, definitely. But there's something it lacks when it's confined to a browser tab.
A body.
When intelligence can walk into a room, read the terrain, make a real-time decision, and act on it, that's when everything changes. That's when the gap between "software" and "the physical world" starts to close. That's when AI stops being a tool you use and starts being something that operates alongside you.
The Go2 sits right at that intersection. It's not replacing your dog. It's not a novelty gadget for tech bros to show off at parties. It's a very real, very capable glimpse into a world where intelligent systems don't just run in the cloud, they walk among us.

Make Your Personal Blog Website with Wagtail CMS

Tarun Kumar — Thu, 29 Jan 2026 05:47:52 +0000

I’ve been wanting to build my own blog for a while now, and after trying out a bunch of different platforms like WordPress and some CMSs, I finally found Wagtail. And honestly? It’s been pretty great. Let me tell you why I think Wagtail is perfect for a personal blog and how you can get started with it.

Why I Chose Wagtail

I know what you’re thinking: “There are like a million blogging platforms out there—why Wagtail?” Fair question. Here’s the thing: I wanted something flexible enough to customize, but not so complicated that I’d spend weeks just setting it up. Wagtail is very easy to set up and customize with templates, but you still get the power and flexibility you need.

And Wagtail is 10x faster than a WordPress website, and because it has much batter seo feature

It’s built on Django, which I already have some experience with, and it provides a really clean admin interface that doesn’t feel like it was designed in 2005. Plus, it’s open source, which means no monthly fees eating into my coffee budget.

What You’ll Need

Before we dive in, here’s what you should have ready:

Python 3.8 or higher is installed on your machine
Basic understanding of Python (you don’t need to be an expert, trust me)
A code editor – I use VS Code, but use whatever makes you happy
Some command line knowledge (nothing crazy, just the basics)

Getting Started

Alright, let’s actually build this thing. First, I recommend setting up a virtual environment because you don’t want to mess up your system Python packages.

python -m venv myenv
source myenv/bin/activate  # On Windows: myenv\Scripts\activate

Now install Wagtail:

pip install wagtail

Once that’s done, create your project:

wagtail start myblog

cd myblog
pip install -r requirements.txt
python manage.py migrate
python manage.py createsuperuser

That last command will ask you to create an admin account. Don’t forget those credentials – you’ll need them to log into your admin panel.

Now fire it up:

python manage.py runserver

Go to http://127.0.0.1:8000 and boom – you’ve got a Wagtail site running. The admin panel is at http://127.0.0.1:8000/admin.

Setting Up Your Blog

Here’s where it gets fun. Wagtail is all about creating custom page types. For a blog, you’ll want to create models for your blog index page and individual blog posts.

Create a new app for your blog:

python manage.py startapp blog
Then add it to your INSTALLED_APPS settings file.

In your blog/models.py, you’ll want something like this:

from django.db import models
from wagtail.models import Page
from wagtail.fields import RichTextField
from wagtail.admin.panels import FieldPanel
from wagtail.search import index

class BlogIndexPage(Page):
    intro = RichTextField(blank=True)

    content_panels = Page.content_panels + [
        FieldPanel('intro')
    ]

class BlogPage(Page):
    date = models.DateField("Post date")
    intro = models.CharField(max_length=250)
    body = RichTextField(blank=True)

    search_fields = Page.search_fields + [
        index.SearchField('intro'),
        index.SearchField('body'),
    ]

    content_panels = Page.content_panels + [
        FieldPanel('date'),
        FieldPanel('intro'),
        FieldPanel('body'),
    ]

Run migrations again:

python manage.py makemigrations
python manage.py migrate

Creating Templates

Wagtail needs templates to display your pages. Create a blog/templates/blog directory and add your templates there. Here’s a simple one for blog_page.html:

{% extends "base.html" %}
{% load wagtailcore_tags %}

{% block content %}
    <h1>{{ page.title }}</h1>
    <p class="meta">{{ page.date }}</p>
    <div class="intro">{{ page.intro }}</div>
    <div class="body">{{ page.body|richtext }}</div>
{% endblock %}

Adding Some Style

The default Wagtail setup is pretty bare-bones, which is actually good because you can style it however you want. I added some basic CSS to make mine look decent, and I’m planning to customize it more as I go.

You can put your CSS in a static folder and link it in your base template. Nothing fancy is needed unless you want to get fancy.

What I Like About This Setup

After using this for my own blog, here’s what I appreciate:

The admin interface is actually pleasant to use. I can draft posts, schedule them, and manage everything without wanting to throw my laptop out the window. The StreamField feature (which I didn’t cover here, but you should definitely look into) lets you create really flexible page layouts. And since it’s Django under the hood, I can add any custom functionality I want.

A Few Gotchas

It’s not all sunshine and rainbows, though. The learning curve is steeper than something like WordPress if you’re not familiar with Python or Django. And while the documentation is pretty good, sometimes you’ll need to dig around to figure out how to do something specific.

Also, deployment is on you. Wagtail doesn’t come with hosting, so you’ll need to figure that out yourself. I ended up using a simple VPS, but there are easier options like PythonAnywhere or Heroku if you don’t want to deal with server management.

Final Thoughts

Building a blog with Wagtail has been a really good experience for me. It’s given me way more control than I’d get with a typical blogging platform, and I actually understand how everything works. If you’re comfortable with Python and want a blog that you can customize to your heart’s content, I’d definitely recommend giving Wagtail a shot.

Simple 5-Step Roadmap to Build Your Own Generative AI

Tarun Kumar — Wed, 28 Jan 2026 11:34:23 +0000

If you want to build your own AI? Not just use ChatGPT, but actually create one? I’ve been there, and let me tell you, it’s easier than you think if you follow the right path. Let me break it down into 5 clear steps that actually work.

Learn the Basics

Before you touch any code, you need to understand what you’re building.

Understand:

What LLMs / Generative AI actually are
Basics of Machine Learning & Deep Learning
Python, PyTorch, Transformers
Easiest start: Take a beginner course (Udemy / Coursera / free YouTube).

Look, I know “learn the basics” sounds boring, but trust me, skipping this is like trying to build a house without knowing what a hammer is. You don’t need a PhD, just solid foundations.

Spend 2-3 weeks here. Watch videos during breakfast, code during lunch breaks, and practice in the evening. The goal isn’t perfection, it’s understanding enough not to feel lost in the next steps.

My recommendation: For Python + PyTorch, there are tons of free YouTube crash courses that’ll get you up to speed fast.

Choose a Base Model

Here’s where beginners waste months: trying to train everything from zero.

Instead of building everything manually:

Pick a pretrained model (LLaMA, Mistral, GPT-style models)
Download models from Hugging Face
Decide model size based on your hardware (7B, 13B, etc.)
Training from scratch is expensive; fine-tuning is smarter.

Think of it like cooking. You wouldn’t grow wheat from seeds to make bread, right? You’d buy flour and bake. Same logic here—start with a pretrained model and customize it.

I started with LLaMA 2 7B because it runs on consumer GPUs. Check your hardware first:

Got a good GPU (RTX 3090, 4090)? Try 7B-13B models
Using Google Colab? Stick to smaller models or use quantized versions
Have a cloud budget? Go bigger, but watch those bills
Pro tip: Hugging Face is your best friend. Browse their model hub, read the model cards, and pick one that fits your use case.

Prepare Your Dataset

Your AI is only as good as the data you feed it. Garbage in = garbage out.

Steps:

Collect domain-specific data (text, Q&A, chats, documents)
Clean the data (remove noise, duplicates, weird formatting)
Convert it into training format (JSON / CSV / instruction-response)
Example format:

{
  "instruction": "Explain REST API",
  "response": "A REST API is..."
}

This step takes longer than you think. I spent 60% of my time just cleaning data on my first project. Remove broken text, fix encoding issues, and filter out junk.

Where to get data:

Your own documents or chat logs
Public datasets (Kaggle, Hugging Face Datasets)
Web scraping (be ethical and legal about it)
Synthetic data generation using existing LLMs
Quality > Quantity. 1,000 high-quality examples beat 100,000 messy ones.

Fine-Tune the Model

This is where the magic happens. This is where your AI becomes yours.

Use techniques like:

LoRA / QLoRA (efficient, uses less memory)
PEFT (Parameter-Efficient Fine-Tuning)
Process:

Train in batches on GPU (local or cloud)
Monitor loss and outputs
Iterate and improve
This is where your AI becomes yours.

Here’s what actually happens: You take that base model and teach it your specific style, knowledge, or task. Want an AI that writes like you? Fine-tune it on your writing. Want a customer support bot? Fine-tune it on support conversations.

Tools I use:

Hugging Face transformers library
Perfect library for LoRA
bitsandbytes for quantization
Google Colab or RunPod for GPU access
Real talk: Your first fine-tuning will probably give weird results. That’s normal. Tweak your hyperparameters, adjust your dataset, try again. I went through 7 iterations before I got something decent.

Watch for:

Loss going down = good
Loss exploding or staying flat = something’s wrong
Model repeating itself = might be overfitting
Complete nonsense = check your data format
Test, Deploy, and Iterate
You’ve got a fine-tuned model. Now what?

Test it thoroughly:

Try edge cases and weird inputs
Compare outputs with the base model
Get feedback from real users (friends, colleagues, beta testers)
Deploy it:

Local deployment: Use llama.cpp or Ollama
API deployment: FastAPI + Hugging Face Inference
Cloud deployment: AWS, Google Cloud, or specialized LLM hosts

Keep improving:
Collect user queries that fail. Add them to your training data. Refine-tune periodically monitor performance and costs.

The Harsh Truths Nobody Mentions

Let me keep it real with you:

Hardware matters. You’ll need a decent GPU or cloud credits. Google Colab free tier works for learning, but you’ll outgrow it fast. Budget $50-200/month for serious work.

It will break. A lot. Out of memory errors, CUDA crashes, and weird tokenization issues. Google the error, check GitHub issues, ask in Discord communities. Everyone goes through this.

Your first model will be underwhelming. It’ll be slow, give mediocre outputs, and you’ll wonder if you did something wrong. You probably didn’t—this is just part of the process.

Data preparation is 70% of the work. Accept this now and save yourself frustration later.

Resources to Get You Started
Learning:

Fast.ai (practical deep learning)
Hugging Face course (free and excellent)
Andrej Karpathy’s YouTube channel

Communities:

r/LocalLLaMA on Reddit
Hugging Face Discord
AI alignment forums
Tools:

Hugging Face Transformers
Axolotl (fine-tuning framework)
LM Studio (local testing)

Final Thoughts

Building your own AI isn’t as scary as it sounds. Yes, there’s a learning curve. Yes, you’ll hit obstacles. But the feeling when you type something into your own AI and it responds intelligently? Absolutely worth it.

A year ago, I couldn’t code. Now I’ve built and deployed three custom LLMs. If I can do it, you can definitely do it too.

What is RAG?

Tarun Kumar — Tue, 27 Jan 2026 10:37:38 +0000

So you’ve undoubtedly heard the term “RAG” thrown around in AI chats and are wondering what it means. Don’t worry, it’s not as complicated as it seems, and I’ll explain it in plain English.

The Basics
RAG stands for Retrieval-Augmented Generation. I know that sounds super technical. But here’s the thing: it’s actually a pretty clever solution to a problem that AI models have been dealing with for a while now.

Think about it this way. You know how sometimes you’re chatting with an AI, and it just makes stuff up? Like, it sounds confident, but it’s completely wrong? That’s called hallucination, and it happens because these models are basically working from memory. They were trained on a bunch of data up until a certain point, and after that, they’re flying blind.