Forem: Hrishika Malviya

From a College Hackathon Idea to an Unfinished Developer Dream — Reviving AlgoPair 🚀

Hrishika Malviya — Sat, 23 May 2026 05:36:20 +0000

GitHub Finish-Up-A-Thon Challenge Submission

There’s a very different kind of nostalgia in opening an old GitHub repository.

Not the happy kind.

The dangerous kind 😭

The kind where you stare at old folders, unreadable code, random commits like final_final_v2_REAL, and suddenly remember how excited you once were while building it.

That’s exactly what happened when I reopened AlgoPair.

A project my team and I built during our college internal hackathon last year.

At that time, the idea felt genuinely exciting.

Not because it was revolutionary.

But because it solved a problem we ourselves faced almost every day.

💭 The Idea Behind AlgoPair

If you’ve ever practiced DSA with friends, you probably know the struggle.

One person opens LeetCode.
Another joins on Discord.
Someone shares their screen.
Someone disconnects.
Half the time goes into explaining code instead of solving problems together 😭

So during our hackathon, we thought:

“What if friends could solve DSA questions together in real time… even from different locations?”

That simple thought became AlgoPair.

A collaborative coding workspace where students could:

💻 Solve DSA questions together
🧠 Discuss approaches in real time
⚡ Write and sync code live
📞 Stay connected remotely while practicing

It was basically our attempt at making “multiplayer DSA practice” feel smooth and interactive.

And honestly?

During the hackathon, we were obsessed with the project.

Late-night debugging.
Cold coffee.
Zero sleep.
Last-minute UI fixes five minutes before evaluation 😭

Typical hackathon energy.

At that moment, AlgoPair genuinely felt like something we would continue building even after the event ended.

But reality works differently.

🫠 The Project Slowly Got Abandoned

Once the hackathon ended, college life came back at full speed.

Assignments.
Exams.
Deadlines.
Burnout.

And slowly, AlgoPair became “that GitHub repo I’ll finish someday.”

The project technically worked…

…but only barely.

The real-time syncing was inconsistent.
Some UI sections were incomplete.
Authentication had issues.
Responsive design was almost nonexistent.
The codebase had become messy after the hackathon rush.

And because everything was built quickly, continuing the project later started feeling overwhelming.

So the repository stayed untouched for months.

Still public on GitHub.

Still unfinished.

💡 Then This Challenge Changed Something

When I came across the GitHub Finish-Up-A-Thon challenge, AlgoPair was the first thing that came to my mind.

Not because it was my most advanced project.

But because it was the one I never fully gave up on.

Most developers have at least one unfinished project sitting quietly in their GitHub profile.

A project they genuinely cared about…
but never got the chance to properly complete.

AlgoPair became that project for me.

And this challenge finally pushed me to stop saying:

“I’ll finish it later.”

🛠️ Rebuilding AlgoPair After Months

Coming back to old code is honestly terrifying 😭

Especially hackathon code.

Everything feels confusing when you revisit it months later.

But this time, instead of trying to rebuild everything from scratch, I focused on improving the project step by step.

That approach changed everything.

✨ Cleaning the Messy Structure

The first version of AlgoPair had:

Duplicate components
Hardcoded values everywhere
Poor folder organization
Repeated logic
Large unreadable files

I spent time restructuring the entire project properly.

Separating reusable components.
Improving readability.
Making the frontend easier to scale.

And surprisingly, GitHub Copilot helped a lot during this phase.

Not by magically “building the app for me”…

…but by helping me move faster whenever I got stuck refactoring old logic.

🎨 Making the UI Feel Like a Real Product

One thing I realized while rebuilding the project:

A polished UI makes a project feel alive again.

So I redesigned major parts of the platform.

I improved:

✅ Dashboard layout
✅ Real-time collaboration sections
✅ Dark mode support
✅ Mobile responsiveness
✅ Cleaner coding workspace
✅ Better spacing and navigation

Instead of looking like a rushed hackathon demo, the platform finally started feeling usable.

And that feeling genuinely motivated me to continue building.

⚡ Features That Made AlgoPair Better

While rebuilding the project, I also expanded the original idea.

The newer version now focuses more on collaborative learning instead of just code syncing.

Some features I added/improved:

🧠 Real-time collaborative coding
💬 Discussion/chat while solving
📈 Coding progress tracking
🔥 Daily consistency tracking
🎯 Better problem organization
📱 Responsive design for different devices

One feature I personally loved building was the coding activity tracker inspired by GitHub contribution graphs.

It visually shows how consistently users practice DSA together.

That small feature made the platform feel much more community-driven.

📚 What Reviving This Project Taught Me

Starting projects is exciting.

Finishing them is difficult.

Hackathons teach you how to build fast.

But unfinished projects teach you patience.

Reviving AlgoPair made me realize something important:

Not every abandoned project is a failure.

Sometimes projects are simply paused versions of ideas we still believe in.

And honestly, rebuilding something old felt far more meaningful than starting another random new project.

Because this time, it wasn’t about just impressing judges during a hackathon.

It was about finally completing something I once cared deeply about building.

❤️ Final Thoughts

A year ago, AlgoPair was just a college hackathon submission built under pressure and sleep deprivation 😭

Today, it feels like an actual product with real potential.

Maybe not perfect yet.

But finally moving in the right direction.

And I think that’s what this challenge is really about.

Not perfection.

Just refusing to leave good ideas unfinished.

Sometimes the best projects aren’t the ones that start perfectly.

I Let Hermes Agent Handle Real Work for 24 Hours — Here’s What Surprised Me 🚀

Hrishika Malviya — Sat, 23 May 2026 05:25:44 +0000

Google Docs summaries, task planning, research help, workflow automation… I wanted to know whether Hermes Agent was actually useful or just another flashy AI demo. 👀

Like many developers, I’ve seen countless “AI agents” online recently. Most of them look impressive for five minutes and then fall apart the moment you give them real work.

So instead of watching another demo video, I decided to do something more interesting:

👉 I gave Hermes Agent actual tasks for an entire day.

Not toy prompts.
Not “write me a poem.”
Real tasks that I normally do myself.

And honestly? Some of the results genuinely surprised me.

First Impressions 💡

The first thing that stood out to me about Hermes Agent was that it didn’t feel like a normal chatbot.

Most AI assistants wait for instructions. Hermes Agent felt more like a system that wanted to figure things out step-by-step.

That difference became obvious very quickly.

What also caught my attention was the flexibility. Unlike many closed AI systems, Hermes Agent can run on your own infrastructure and connect with different models and tools. That open-source approach already makes it interesting for developers who like control and customization.

You can explore the project here:

Hermes Agent Official Website
Hermes Agent GitHub Repository
The Experiment 🧪

I decided to treat Hermes Agent like an AI intern for one full day.

Here were the tasks I gave it:

✅ Research assistance
✅ Summarizing long information
✅ Planning workflows
✅ Multi-step reasoning tasks
✅ Organizing ideas
✅ Helping with coding-related work
✅ Remembering context between tasks

I wasn’t expecting perfection.
I mainly wanted to see one thing:

Could this agent actually reduce my workload in a meaningful way?

Task 1: Research and Summarization 📚

I started with something simple.

I gave Hermes Agent a large amount of information and asked it to summarize the key points and organize them clearly.

This is where I noticed the first major difference compared to normal chatbots.

Instead of giving a quick surface-level answer, Hermes Agent tried to break the task into smaller reasoning steps. It felt more structured and intentional.

And surprisingly, the summaries were actually useful — not just random bullet points copied from the input.

That immediately made me think:

“Okay… this might be more powerful than I expected.” 👀

Task 2: Multi-Step Workflow Planning ⚙️

Next, I tested something harder.

I asked Hermes Agent to help plan a small workflow involving multiple steps and dependencies.

This is where many AI tools usually struggle. They often lose context or generate inconsistent steps halfway through.

Hermes Agent handled this much better than I expected.

It broke the task into:

goals,
subtasks,
logical sequences,
and execution ideas.

It genuinely felt like the agent was thinking through the process instead of just predicting the next sentence.

That distinction matters a lot.

The Most Interesting Part: It Felt Persistent 🧠

One of the biggest reasons Hermes Agent stood out to me was its approach to memory and persistence.

Most AI chats feel temporary. You ask something, get a response, and everything disappears into the void.

Hermes Agent feels different because it’s designed around:

learning,
memory,
skills,
and long-term improvement.

That changes the experience completely.

At one point, I noticed it referencing earlier context more naturally than I expected, and that small moment honestly made the system feel far more “agentic” than typical AI assistants.

Not magical.
Not perfect.
But definitely different.

Where Things Got Messy 😅

Of course, not everything worked perfectly.

There were moments where:

outputs became repetitive,
reasoning drifted slightly,
or tasks required clearer instructions than I initially gave.

And honestly, I’m glad those moments happened.

Because it made the experience feel real.

One thing I’ve realized while testing AI systems is that the most trustworthy reviews are the ones that include failures too.

Hermes Agent is powerful, but it’s still a tool that benefits from good prompting, structured tasks, and realistic expectations.

What Actually Impressed Me Most 🚨

It wasn’t the speed.

It wasn’t flashy outputs.

It was the feeling that Hermes Agent was trying to operate through tasks rather than simply answer prompts.

That sounds like a small difference, but it changes everything.

For the first time in a while, I felt like I was interacting with something closer to an AI workflow system rather than a standard chatbot interface.

And I think that’s exactly why so many developers are paying attention to agentic AI right now.

Open-Source AI Feels Important Again 🌍

Another thing that made this experience exciting was the open-source side of Hermes Agent.

In a world where most advanced AI systems are becoming increasingly closed and centralized, there’s something refreshing about tools that developers can actually:

run themselves,
customize,
inspect,
and experiment with freely.

That openness creates room for innovation.

And honestly, some of the most interesting AI experiments in the next few years might come from open communities rather than giant corporations alone.

Final Thoughts 💭

After spending a day testing Hermes Agent with real work, I don’t think AI agents are just hype anymore.

Are they perfect? No.

Are they fully autonomous replacements for humans? Definitely not.

But systems like Hermes Agent show where things are heading:

persistent AI,
tool-using AI,
self-improving workflows,
and agents that can genuinely assist with complex tasks.

The most surprising part?

For the first time, I stopped feeling like I was “chatting with AI” and started feeling like I was coordinating with a system that could actually help manage work.

And that shift feels important. 🚀

Thanks for Reading 🙌

If you’ve experimented with Hermes Agent or other agentic systems, I’d genuinely love to hear your experience too.

The AI agent space is evolving incredibly fast, and it feels like we’re only beginning to see what these systems might eventually become.

“I Built a Fully Offline AI Memory Engine Around Gemma 4 — No Cloud, No Vector DB”

Hrishika Malviya — Sat, 23 May 2026 05:11:59 +0000

Most AI assistants today are impressive… until you realize they forget everything unless you connect them to expensive cloud infrastructure, embeddings APIs, or vector databases.

That never felt right to me.

I kept wondering:

“Can an AI remember useful things intelligently without relying on Pinecone, ChromaDB, or cloud memory systems?”

So over the past few days, I built an experimental offline AI memory engine powered entirely by Gemma 4.

No cloud.
No vector database.
No external APIs.
Just local inference, smart memory ranking, and a lot of late-night debugging ☕💀

🧠 The Goal

I didn’t want to build another chatbot wrapper.

I wanted to explore something deeper:

How can we make local AI systems remember information in a smarter and lighter way?

Most memory systems today work like this:

User Message → Embeddings → Vector DB → Similarity Search → AI

Mine works differently.

Instead of embeddings and vector search, I experimented with:

memory compression
keyword scoring
relevance ranking
contextual summaries
priority-based recall
local JSON/SQLite storage

Everything runs fully offline.

⚡ What The System Does

The AI can:

✅ remember important conversations
✅ recall ideas across sessions
✅ store goals/projects/tasks
✅ rank memories by importance
✅ retrieve relevant context locally
✅ work completely offline

For example:

You can say:

“Remember my startup idea about offline education.”

And later ask:

“What startup ideas did I save earlier?”

The system rebuilds context dynamically and feeds only the most relevant memories back into Gemma 4.

🔥 Why I Avoided Vector Databases

Vector databases are powerful, but I wanted to test something simpler.

Modern LLMs already have strong reasoning capabilities.

So instead of relying heavily on embeddings, I focused on:

smarter context building
compressed memory summaries
lightweight ranking logic
structured memory retrieval

Surprisingly…

It worked much better than I expected 👀

🏗️ Tech Stack
AI
Gemma 4
Ollama
Backend
FastAPI
Python
Frontend
Next.js
Tailwind CSS
Framer Motion
Storage
SQLite
JSON memory store

Everything runs locally on my laptop.

🧩 How The Memory Engine Works

The architecture is pretty simple:

User Input
↓
Memory Extractor
↓
Local Memory Store
↓
Relevance Ranking
↓
Context Builder
↓
Gemma 4 Response

The interesting part was building a system that decides:

“What is actually worth remembering?”

Not every message should become memory.

That part took the most experimentation.

💡 What I Learned

This project taught me something important:

Sometimes we overcomplicate AI systems.

You don’t always need:

massive infrastructure
cloud pipelines
complex retrieval systems

With the right architecture, local AI can already feel surprisingly intelligent.

And honestly…

There’s something really satisfying about seeing an AI system work completely offline 🔥

📊 Current Results

So far the system can:

maintain long-term memory surprisingly well
recall relevant information across sessions
run smoothly on consumer GPUs
operate fully offline after setup

Still experimenting with:

memory decay
smarter ranking
long-context optimization
hallucination reduction

But the early results are exciting.

🚀 What’s Next

I’m planning to explore:

memory graphs
adaptive memory compression
persistent AI personas
offline multi-agent memory systems
local “second brain” workflows

Gemma 4 has been incredibly fun to experiment with for these kinds of systems.

Final Thoughts

I started this project mostly as an experiment.

But somewhere during the process, it stopped feeling like a chatbot project…

…and started feeling like the foundation of a real personal AI system.

Offline AI is getting seriously powerful.

And I think we’re only getting started. 🔥

Google I/O 2026 Didn’t Kill Coding — It Changed Who Controls It

Hrishika Malviya — Fri, 22 May 2026 05:48:05 +0000

When I started watching Google I/O 2026, I thought it would be another polished tech event.

Some AI demos.
Some productivity upgrades.
A few “future of development” promises.

But halfway through the keynote, I stopped watching like a developer.

I started watching like someone realizing the industry is mutating in real time.

Because this year Google didn’t introduce better coding tools.

They introduced systems that are slowly learning how to replace the entire process of software development.

The Shift Nobody Wants To Admit

For years, developers believed AI would stay an assistant.

Helpful, but controlled.

Something that suggests code while humans stay in charge.

Google I/O 2026 completely broke that illusion.

Now AI agents:

plan projects,
execute workflows,
debug themselves,
deploy apps,
communicate between tools,
and even continue unfinished work autonomously.

That’s not assistance anymore.

That’s delegation.

And delegation eventually changes jobs forever.

Antigravity Is More Dangerous Than People Realize

Everyone online is hyping Gemini.

But honestly?

Antigravity scared me more.

Because Gemini is a model.

Antigravity is a developer ecosystem where AI agents operate almost like independent workers.

One agent writes backend logic.
Another handles testing.
Another checks vulnerabilities.
Another deploys infrastructure.

Parallel execution.

Continuous reasoning.

Minimal human interruption.

This is the first time I genuinely felt like big tech companies are no longer trying to support developers.

They’re trying to redesign development itself.

Developers Used To Build Products

Now Developers May Only Supervise Them

That’s the real difference after I/O 2026.

Earlier:

humans built,
AI assisted.

Now:

AI builds,
humans supervise.

And once that transition becomes normal, the industry changes permanently.

Because companies care about:

speed,
scalability,
cost reduction,
and automation.

An AI agent doesn’t sleep.
Doesn’t burn out.
Doesn’t ask for salary hikes.
Doesn’t need onboarding.

That’s the uncomfortable business reality nobody says out loud.

WebMCP Might Quietly Become The Biggest Internet Shift Since Mobile

Most people ignored WebMCP because it sounded technical.

Huge mistake.

Because WebMCP is basically teaching websites how to communicate directly with AI agents.

Right now agents interact with websites like confused humans:

clicking buttons,
reading layouts,
guessing actions.

WebMCP changes that.

Now websites can expose structured AI-readable tools directly.

Meaning future apps won’t only compete for human attention.

They’ll compete for AI compatibility too.

That changes web development forever.

In the future, developers may optimize apps for:

users,
search engines,
AND intelligent agents.

That’s an entirely new layer of the internet.

The Most Terrifying Realization I Had

The problem isn’t that AI writes code fast.

The problem is that AI is removing friction everywhere.

Google showed:

instant deployment,
automatic testing,
migration agents,
full-stack scaffolding,
cloud integration,
security analysis,
autonomous workflows.

All the painful parts developers spent years mastering…

are becoming automated.

And when hard things become easy, industries restructure fast.

But Here’s Why I Don’t Think Developers Are Finished

I think average developers are in danger.

Not great developers.

Because AI still lacks:

deep business understanding,
product intuition,
accountability,
human creativity,
long-term engineering judgment.

AI can generate systems.

But it still struggles understanding consequences.

And companies eventually pay for bad decisions more than slow development.

That’s where real developers still matter.

The New Era Won’t Reward “Coders”

It will reward:

system thinkers,
AI orchestrators,
technical strategists,
builders with product sense.

The future developer isn’t the person typing the fastest.

It’s the person directing intelligence effectively.

That’s a completely different skillset.

What Changed For Me Personally After Watching I/O 2026

Before this event, I thought learning more frameworks was enough.

Now I think that mindset is outdated.

Because frameworks change.

Syntax changes.

Tools change.

But understanding systems, users, scalability, and architecture stays valuable.

So if I were rebuilding my skillset today, I’d focus on:

AI workflows,
automation systems,
cloud architecture,
cybersecurity,
product engineering,
and agent collaboration.

Not endless tutorial watching.

Not memorizing syntax.

Those things are becoming commodities.

The Biggest Mistake Developers Will Make

Either:

completely rejecting AI,

depending on it blindly.

Both are dangerous.

The smartest developers will be the ones who:

understand fundamentals deeply,
but also use AI aggressively.

That balance will create the next generation of elite engineers.

Final Thought

Google I/O 2026 didn’t feel exciting to me.

It felt historic.

Like one of those moments people look back at years later and say:

“That was the moment everything changed.”

Because this wasn’t just a keynote about AI products.

It was a preview of a world where software increasingly builds itself.

And honestly?

I don’t think the industry is fully prepared for how fast that future is approaching.

googleiochallenge #devchallenge #ai #gemini