DEV Community: 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 feeling when you open an old GitHub repository after almost a year.

A few weeks ago, while scrolling through my GitHub profile, I came across AlgoPair — a project my team and I built during our college internal hackathon in 2025.

At the time, we were excited about the idea because it solved a problem we personally faced while practicing DSA. We often wanted to solve coding problems together, but coordinating through screen sharing, Discord calls, and multiple tabs was frustrating. That led us to build AlgoPair, a collaborative platform where students could work on coding problems together in real time.

Like many hackathon projects, we managed to get a working prototype ready before the deadline. The demo worked, the judges liked the concept, and we were proud of what we had built.

Then the hackathon ended.

Classes, assignments, exams, and other commitments gradually took priority. Although I always intended to continue working on AlgoPair, the repository remained untouched for months.

When I discovered the GitHub Finish-Up-A-Thon challenge, AlgoPair immediately came to mind. It wasn't my most complex project, but it was the unfinished project I cared about the most.

Returning to the codebase after such a long time was honestly harder than I expected. Understanding old implementation decisions, cleaning rushed hackathon code, and fixing unfinished features took significant effort. Instead of rebuilding everything from scratch, I focused on improving one section at a time.

Some of the improvements included:

Refactoring and organizing the project structure
Removing duplicate code and reusable logic issues
Improving the user interface and navigation
Adding better responsive design support
Enhancing collaboration-related features
Improving overall maintainability of the codebase

One of my favorite additions was a coding activity tracker inspired by GitHub contribution graphs. It helps visualize user consistency and makes collaborative practice feel more engaging.

The biggest lesson from this experience was that unfinished projects are not necessarily failed projects. Sometimes they are simply ideas waiting for the right opportunity and motivation to continue.

For me, Finish-Up-A-Thon provided exactly that motivation.

ABotWroteThis

This article was written with the assistance of ChatGPT. I used AI to help improve grammar, readability, and structure while writing this post.

The project, experiences, challenges, and reflections shared here are based on my own work rebuilding AlgoPair for the GitHub Finish-Up-A-Thon challenge.

I reviewed and edited the final content before publishing to ensure it accurately reflects my experience and the current state of the project.

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

I’ve been seeing “AI agents” everywhere lately. Every other tool claims it can automate work, plan tasks, or act like a smart assistant. But most of them look impressive in demos and then feel pretty limited in real use.

So instead of just watching another video or reading marketing claims, I decided to actually use Hermes Agent for a full day and see what it does with real work.

Not toy prompts. Not “write me a poem.”
Just normal tasks I usually handle myself.

First impression

It didn’t feel like a normal chatbot.

Most AI tools wait for you to ask something and then respond. Hermes Agent felt a bit more active in comparison — like it was trying to break the task into steps instead of answering in one go.

Also, since it’s open-source and can be run on your own setup, it gives more control than most closed AI tools. That already makes it interesting for developers.

What I tested

I basically used it like a small assistant for the day. I gave it tasks like:

Researching topics
Summarizing long text
Planning simple workflows
Breaking down multi-step problems
Organizing ideas
Helping with small coding tasks
Keeping context across tasks

My main goal was simple: see if it actually saves time in real work.

Research and summarization

I started with long content and asked it to summarize and organize it.

What I noticed was that it didn’t just shorten everything. It tried to structure the information in a more readable way.

It wasn’t perfect, but it was useful enough that I didn’t feel like I had to rewrite everything from scratch.

Workflow planning

This part was more interesting.

I asked it to plan a small workflow with multiple steps.

Where many AI tools struggle is structure — they either oversimplify or lose consistency midway.

Here, it did better. It broke the task into clear parts like:

what needs to be done
smaller steps
order of execution
basic flow of the process

It actually felt like it was thinking through the task instead of just responding.

Context and memory

One thing I noticed was that it handled context better than basic chat tools.

It wasn’t perfect memory, but during the session it did refer back to earlier inputs in a more natural way than I expected.

That makes a difference when you’re working on multiple related tasks instead of isolated prompts.

Where it struggled

It wasn’t smooth everywhere.

There were moments where:

it repeated similar points
longer tasks lost some clarity
results depended heavily on how clearly I wrote the prompt
sometimes the depth wasn’t consistent

So it definitely still needs proper guidance.

What stood out

The main thing I noticed wasn’t speed or output quality.

It was the behavior.

Instead of just answering questions, it often tried to process the task step-by-step. That small shift makes it feel less like a chatbot and more like a task-based system.

That’s probably the biggest difference compared to normal AI tools.

Open-source factor

Another plus point is that it’s open-source.

That means you can:

run it locally or on your own setup
modify it
connect different tools
experiment freely

For developers, that flexibility is a big deal.

Final thoughts

After using Hermes Agent for a full day, I wouldn’t call it perfect or fully “agent-like” in a real autonomous sense.

But it’s also not just another chatbot with a fancy label.

It sits somewhere in between — still developing, but clearly moving toward more structured, workflow-based AI.

The biggest change I felt was simple:

Instead of just chatting with an AI, it felt more like giving tasks to a system that tries to execute them step by step.

That direction feels more useful than hype.

Disclosure

This write-up is based on the user’s hands-on testing experience with Hermes Agent. The content has been structured and refined for clarity and readability using AI assistance.

“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 feel impressive at first.

They answer fast, sound smart, and can handle a lot of tasks. But the moment you step away for a bit or restart a session, everything is gone. No memory. No continuity. Just a fresh start again.

And honestly, that always felt a bit broken to me.

I kept wondering:

Why does AI still depend so heavily on cloud memory systems, vector databases, and external APIs just to “remember” simple things?

So instead of just thinking about it, I decided to try something myself.

Over the past few days, I built an experimental offline AI memory system using Gemma 4.

No cloud.
No vector database.
No external APIs.

Just local inference and a simple idea: what if memory could be handled in a lighter, more human-like way?

Where the idea started

I didn’t want to build another chatbot wrapper or a fancy UI on top of an LLM.

The real goal was something deeper:

Can an AI system remember useful information without heavy infrastructure?

Most modern systems solve memory like this:

User input → embeddings → vector database → similarity search → context injection

It works, but it also feels… over-engineered for many use cases.

So I tried a simpler approach.

Instead of relying on embeddings, I experimented with:

simple memory compression
keyword-based scoring
relevance ranking
structured summaries
priority-based storage
local JSON and SQLite storage

Everything runs completely offline.

What I actually built

The system is basically a small memory layer on top of an LLM.

It can:

store important information from conversations
remember goals, ideas, and tasks
recall past context across sessions
rank memories by importance
bring back only relevant information when needed

For example, if I say:

“Remember my idea about offline education startups.”

Later, I can ask:

“What startup ideas did I mention earlier?”

And instead of blindly searching everything, the system tries to rebuild context and only pass the most relevant memories back to the model.

The interesting part: deciding what to remember

The hardest part wasn’t storing data.

It was deciding what actually deserves to be remembered.

Because if you store everything, memory becomes noisy and useless.

So I had to experiment a lot with filtering logic — figuring out:

what is important
what is temporary
what should decay over time
what should be summarized instead of stored fully

This part felt less like coding and more like designing “attention” for the system.

Why I avoided vector databases

I know vector databases are the standard solution here.

But I wanted to challenge that assumption a bit.

Modern LLMs are already strong at reasoning. So instead of building a heavy retrieval system, I focused on:

better structuring of memory
lightweight ranking logic
compressed summaries instead of raw embedding matches
smarter context selection

And surprisingly, it worked better than I expected.

Not perfect, but definitely usable in a real workflow.

Tech stack

Just to keep things simple:

AI: Gemma 4 via Ollama
Backend: FastAPI + Python
Frontend: Next.js, Tailwind CSS
Storage: SQLite + JSON files

Everything runs locally on my machine.

No cloud dependencies at all.

How it works (simple version)

User input comes in → system extracts key memory → stores it locally → ranks relevance → builds context → sends to Gemma 4 → generates response

That’s it.

The real complexity is inside the ranking and filtering layer, not the pipeline itself.

What I learned from this

This experiment changed my perspective a bit.

We often overcomplicate AI systems.

Not every problem needs:

vector databases
distributed systems
cloud infrastructure
complex retrieval pipelines

Sometimes, a simpler design is enough to get surprisingly good results.

And running everything locally gives a different kind of satisfaction — it feels like you actually own the system.

Where it stands right now

Right now, the system can:

maintain basic long-term memory
recall relevant information across sessions
run smoothly on a normal machine
work fully offline after setup

But it’s still experimental.

Things I’m still improving:

better memory decay
smarter ranking logic
handling longer context more efficiently
reducing hallucinated recall
What’s next

There are a few directions I want to explore next:

memory graphs instead of flat storage
adaptive compression of older memories
persistent AI personas
multi-agent offline memory systems
“second brain” style AI workflows

Gemma 4 has actually been fun to experiment with for this kind of system.

Final thoughts

This started as a small experiment.

But somewhere along the way, it stopped feeling like a chatbot project.

It started feeling more like a step toward a personal AI system that can actually remember and assist in a meaningful way.

We’re still early in this space.

But one thing is clear:

Offline AI is getting powerful enough that interesting things can already be built without huge infrastructure.

And this is probably just the beginning.

AI Disclosure

This article was written with assistance from an AI language model based on the user’s original project notes and implementation details. The content was edited and structured for readability and clarity.

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