DEV Community: Tanush

From Hackathon Chaos to Clean CLI: Reviving My Daily Routine Analyser with GitHub Copilot

Tanush — Sat, 23 May 2026 15:43:49 +0000

🧠 What I Built

I revived a C-based CLI project called Daily Routine Analyser, originally built during a hackathon under extreme time pressure.

At its core, the tool helps users break down their 24-hour day into:

Study 📚
Sleep 😴
Exercise 🏃
Leisure 🎮

It then calculates a simple productivity score out of 10 and provides insights about daily balance.

What started as a rushed prototype has now been transformed into a clean, modular, and readable CLI application with improved structure and logic.

👉 GitHub Repo: https://github.com/tanush326k/daily-routine-analyser

🎬 Demo

🔗 GitHub Repository:

https://github.com/tanush326k/daily-routine-analyser

💻 How it works:

User enters daily activity hours
Program validates total ≤ 24
System evaluates habit balance
Outputs:
- Time breakdown
- Habit insights
- Final productivity score (/10)

🔁 The Comeback Story

The original version of this project was written during a hackathon in a highly rushed environment.

🔴 Before (Hackathon Version)

Everything inside a single main() function
No modular structure
Hardcoded logic and repetitive flow
Built just to “make it work”

It functioned — but it wasn’t maintainable or scalable.

🟢 After (Revived Version)

When I revisited it, I focused on turning it into something cleaner and more structured:

Refactored code into modular functions
Improved scoring logic clarity
Added structured thinking using struct
Enhanced readability and maintainability
Cleaned up nested loops and logic flow

The goal wasn’t just to fix it — it was to make it feel like a real project, not a hackathon leftover.

🤖 My Experience with GitHub Copilot

GitHub Copilot played a key role in this revival process.

It helped me:

Break down a large main() function into smaller reusable functions
Suggest cleaner implementations for scoring logic
Improve structure using struct for better data organization
Reduce unnecessary nesting and improve readability
Speed up refactoring decisions

Instead of writing everything from scratch again, Copilot acted like a pair programmer helping restructure legacy code into something clean and modern.

💡 Key Takeaway

This project taught me that:

“A hackathon project is not the end — it’s the starting point.”

Even simple ideas can become meaningful software when revisited with better structure and tools.

🚀 Future Improvements

Save daily logs to CSV
Weekly progress tracking system
Graph-based visualization
Habit streak tracking system
Possible GUI/web version

👨‍💻 Closing Note

This project represents my journey from:
“just getting it working” → “making it well-designed and maintainable.”

And GitHub Copilot helped accelerate that transformation significantly.

🧠 Hermes Agent Assistant — A Modular AI Agent System with Planner, Executor & Memory

Tanush — Sat, 23 May 2026 14:43:32 +0000

🚀 What I Built

I built Hermes Agent Assistant, a lightweight agentic AI system designed to demonstrate how modern AI agents can be structured using a modular architecture instead of a simple, single-prompt response model.

The system takes an abstract user task, breaks it down into structured steps using a dedicated planner, executes those steps sequentially via an execution engine, utilizes targeted tools, and stores the interaction context in a persistent memory system.

⚙️ Why I Built This

Most AI applications today are simple wrappers around LLMs that rely on a single input-output loop. I wanted to understand and demonstrate how production-grade, autonomous agent systems operate internally. Specifically, I wanted to explore how:

Planning can be decoupled from execution to allow for complex error handling and multi-step reasoning.
Tools can be dynamically integrated into an agent's reasoning loop.
State and memory can persist across tasks to enable true contextual continuity.

Hermes Agent is my architecture simulation built to solve this problem in a highly accessible, lightweight, and scalable format.

🧠 System Architecture & Workflow

The codebase is split cleanly into four autonomous components that mirror real-world AI agent meshes:

       User Request (e.g., /run?task=...)
                     │
                     ▼
       ┌───────────────────────────┐
       │         PLANNER           │ ➔ Slices abstract goals into 
       └─────────────┬─────────────┘   structured, sequential steps.
                     │
                     ▼
       ┌───────────────────────────┐
       │        EXECUTOR           │ ➔ Orchestrates task completion 
       └─────────────┬─────────────┘   by processing each step.
                     │
                     ▼
       ┌───────────────────────────┐
       │       TOOLS LAYER         │ ➔ Provides functional utilities 
       └─────────────┬─────────────┘   (simulated web search, logic, maths).
                     │
                     ▼
       ┌───────────────────────────┐
       │      MEMORY SYSTEM        │ ➔ Persists execution logs statefully 
       └───────────────────────────┘   into local JSON storage.

📡 Production Showcases & Links

🌐 Live Production Demo: hermes-agent-tanush.onrender.com
💻 Open Source Repository: https://github.com/tanush326k/hermes-agent-assistant.git
🆔 Cloud Deployment Service ID: srv-d88revegvqtc73bdj380 (Render Infrastructure Node)

💡 What Makes It Different

Unlike traditional, rigid APIs or simple conversational chatbots, Hermes Agent:

Thinks in Workflows: It establishes an internal chain-of-thought lifecycle before executing anything.
Separates Reasoning from Action: Slicing the Planner from the Executor prevents cascading generation failures.
Is Highly Extensible: New tools and custom utility logic can be dropped into the system without breaking core routing.
Maintains Context Persistence: The custom memory module ensures state history is preserved between network calls.

🎛️ API Interaction Example

Request

POST /run?task=search AI agents HTTP/1.1
Host: hermes-agent-tanush.onrender.com

Response

{
  "task": "search AI agents",
  "plan": [
    "analyze request parameters", 
    "query tool registry for search utilities", 
    "summarize agent data structural output"
  ],
  "result": "final structured output successfully generated and written to persistent storage."
}

🧰 Tech Stack

Core Language: Python 3.10+
Web Framework: FastAPI (Asynchronous Server Gateway Interface)
Production Server: Uvicorn
Memory Layer: Volatile-to-Persistent JSON state manager
Architecture Pattern: Modular Agentic Workflow Design

🔮 Future Improvements & Roadmap

🤖 Real Foundation LLM Integration: Swapping out simulated logic for live OpenAI, Anthropic, or local open-source Ollama completion hooks.
🗄️ Vector Database Memory Upgrade: Transitioning flatfile storage over to a proper semantic vector indexing framework (FAISS / ChromaDB) for semantic chunk lookups.
🤝 Multi-Agent Orchestration: Upgrading the workflow to host distinct Planner, Executor, and Critic agents working collaboratively with separate system prompts.
⚡ Live Server-Sent Events (SSE): Integrating real-time execution streaming so client frontends can observe the agent's thought process step-by-step.

Google I/O 2026 and the Rise of the AI Ecosystem

Tanush — Sat, 23 May 2026 13:25:53 +0000

Google I/O 2026: The Year AI Became Truly Developer-First

Every year, Google I/O gives us a glimpse into where technology is heading. But this year felt different.

Google I/O 2026 wasn’t just about flashy demos or incremental updates — it felt like a major shift toward making AI genuinely usable for developers, creators, and everyday builders. From Gemini integrations to Firebase AI tooling and Flutter improvements, the announcements painted a clear picture: Google wants AI to become part of every workflow, not just a standalone feature.

After following the keynotes and diving into the sessions, one theme stood out to me:

The barrier between an idea and a working product is shrinking faster than ever.

And honestly, that’s both exciting and a little overwhelming.

The Biggest Takeaway: AI Is Becoming Infrastructure

The most impressive part of this year’s announcements wasn’t a single model or product release. It was how deeply AI is now integrated into Google’s ecosystem.

During the Google Keynote and the “What’s New in Google AI” session, it became obvious that Google is no longer treating AI as an experiment. AI is now infrastructure.

Instead of asking developers to “add AI,” Google is embedding intelligence directly into:

Android development
Search experiences
Firebase workflows
Cloud tooling
Flutter applications
Productivity tools

That changes how we think about software development entirely.

We’re moving from:

Writing every feature manually

To:

Orchestrating systems that can reason, generate, and adapt.

Firebase + AI Was the Most Practical Announcement

Out of everything announced, the Firebase updates were probably the most exciting for me as a developer.

Not because they were flashy.

Because they were immediately useful.

The new AI-powered Firebase workflows seem focused on solving real development bottlenecks:

Faster backend setup
Smarter debugging
Automated app flows
Better AI integrations without huge infrastructure complexity

For indie developers and small teams, this matters a lot.

One of the hardest parts of building modern applications is no longer just coding — it’s managing scale, integrations, authentication, analytics, AI APIs, deployment pipelines, and user experience all at once.

Firebase is evolving into something much bigger than a backend service.

It’s becoming an AI-assisted development platform.

And that’s a huge shift.

Flutter Quietly Had One of the Best Sessions

The “What’s New in Flutter” session didn’t generate the same hype as the AI announcements, but I think it deserves more attention.

Flutter continues to mature into one of the most efficient cross-platform frameworks available today. What stood out this year was Google’s focus on:

Performance improvements
Better tooling
Faster iteration cycles
Stronger AI-assisted workflows for UI development

The interesting part is how AI and Flutter now complement each other.

AI can accelerate:

UI generation
Component scaffolding
Documentation
Testing
State management suggestions

But Flutter still gives developers control over the final experience.

That balance matters.

A lot of AI-generated software today still feels generic. Flutter remains one of the best tools for developers who want productivity without sacrificing creativity.

AI Coding Assistants Are Entering a New Phase

Another thing I noticed across multiple sessions was the evolution of AI coding tools.

Last year, AI assistants mostly helped autocomplete code.

This year, the focus shifted toward:

Multi-step reasoning
Context-aware workflows
Architecture suggestions
End-to-end development assistance

That’s a massive leap.

We’re quickly approaching a world where developers spend less time writing boilerplate and more time:

Designing systems
Reviewing logic
Shaping product experiences
Making architectural decisions

Ironically, AI may make human creativity even more valuable.

Because when everyone can generate code quickly, the real differentiator becomes:

Product thinking
User empathy
Taste
Problem selection

The Most Underrated Shift: Developer Accessibility

One thing I think people are underestimating is how much easier entry into software development is becoming.

A few years ago, building an AI-powered application required:

ML expertise
Infrastructure knowledge
GPU access
Large engineering budgets

Now?
A solo developer can prototype surprisingly advanced applications using Google’s ecosystem.

That democratization is probably more important than any single feature announcement.

The next generation of builders won’t need permission, massive teams, or huge funding rounds to create impactful products.

That changes innovation itself.

My Biggest Question After I/O 2026

As exciting as everything looks, I still have one major question:

How do we prevent AI-assisted development from making software feel identical?

When tools generate interfaces, code structures, and workflows automatically, there’s a risk that creativity becomes standardized.

The challenge for developers moving forward won’t just be learning AI tools.

It’ll be learning how to use them without losing originality.

The best developers in the AI era may not be the people who automate everything.

They may be the people who know where human judgment still matters most.

Final Thoughts

Google I/O 2026 felt less like a product showcase and more like a preview of a new development era.

The biggest innovation wasn’t one model, framework, or API.

It was the growing idea that software creation itself is changing.

Developers are transitioning from:

Writing every system manually

To:

Collaborating with intelligent tools.

And while the technology is impressive, the real opportunity lies in what people choose to build with it.

That’s the part I’m most excited about.

Because the future of development won’t belong to AI alone.

It’ll belong to developers who learn how to work alongside it creatively.

Local AI is Here: Which Gemma 4 Model Should You Actually Use? 🚀

Tanush — Sat, 23 May 2026 13:09:08 +0000

🚀 The Local AI Shift: Choosing Your Gemma 4 Tooling Strategy

The landscape of Large Language Models (LLMs) is shifting. For a long time, the "smart" models lived exclusively in the cloud, behind expensive APIs and strict rate limits.

With the release of Gemma 4, Google has pushed the boundary of what "open weights" can actually do. From native multimodality to a massive 128K context window, Gemma 4 isn't just a research project—it's a developer's toolkit.

But as any developer knows, bigger isn't always better. The Gemma 4 family comes in three distinct flavors. If you're staring at Hugging Face wondering which one to download, this guide is for you.

🛠️ The Gemma 4 Lineup: A Breakdown

Model Variant	Best For	Architecture Focus	Key Benefit
Gemma 4 (2B & 4B)	Mobile, IoT, Browser AI	Extreme Edge Execution	Zero API Cost & Full Privacy
Gemma 4 (31B Dense)	Local Workstations, RAG	Balanced "Goldilocks" Dense	High Stability & Reasoning
Gemma 4 (26B MoE)	High-Throughput Engine	Mixture-of-Experts (MoE)	Speed & Complex Logic

1. The "Edge" Experts (2B and 4B)

Best for: Mobile apps, browser-based AI, IoT, and Raspberry Pi 5.
The Blueprint: These models are optimized for the extreme edge. We are talking about AI that runs locally on a Pixel phone or a tiny credit-card-sized computer without needing an internet connection.
The Use Case: Imagine a privacy-first personal assistant that lives entirely on a user's device, or a smart-home controller that processes voice and text locally to reduce latency.
Why choose this? Minimal RAM usage, zero API costs, and maximum data privacy.

2. The Versatile Workhorse (31B Dense)

Best for: Local workstations, server-grade local execution, and general-purpose apps.
The Blueprint: The 31B Dense model is the "Goldilocks" of the family. It bridges the gap between the lightweight edge models and the high-performance MoE versions.
The Use Case: Building a local coding assistant or a specialized RAG (Retrieval-Augmented Generation) pipeline where you need high reliability and stability across a wide variety of tasks.
Why choose this? It offers a powerful balance of reasoning capabilities and local deployability on consumer GPUs.

3. The Reasoning Specialist (26B MoE)

Best for: High-throughput applications, complex reasoning, and advanced logic.
The Blueprint: The Mixture-of-Experts (MoE) architecture is the secret sauce here. Instead of activating every parameter for every prompt, it only uses a fraction of its weights, making it incredibly efficient without sacrificing "intelligence."
The Use Case: Complex data analysis, automated software engineering tasks, or any application where you need "smarter" reasoning but can't afford the latency of a massive 100B+ parameter model.
Why choose this? High throughput (speed) and superior reasoning logic.

🌟 The "Game Changer" Features

Regardless of which size you choose, three features make Gemma 4 a powerhouse for developers:

🖼️ Native Multimodality
Gemma 4 doesn't just "read" text; it understands images and (in the smaller models) audio natively. This opens the door for apps that can "see" a UI screenshot and write the HTML/CSS to recreate it, or "hear" a meeting and summarize the key action items.

📚 The 128K Context Window
A 128K context window is a massive deal for developers. You can now feed an entire library of documentation, several large source code files, or a massive PDF into the prompt without the model "forgetting" the beginning.

🔓 Open Weights, Open Innovation
Because these are open weights, we aren't just "users" of an API; we are owners of the model. We can fine-tune Gemma 4 on our own proprietary data, quantize it to run on weaker hardware, and deploy it in air-gapped environments.

🚀 How to Get Started Right Now

You don't need a supercomputer to start experimenting. Choose your preferred integration path below:

🛠️ The "Zero Setup" Path
Use Google AI Studio to test the models via API immediately. Great for fast prototyping.

💻 The "Local Dev" Path
Download the weights from Hugging Face or Kaggle and run them using Ollama or vLLM directly in your terminal.

🌐 The "Free Tier" Path
Access the 31B model via OpenRouter's free tier to test the logic before committing to a local install.

🧠 Final Thoughts

The "Local AI moment" is about moving from AI as a Service to AI as an Ingredient. Whether you are building a tiny app for a Raspberry Pi or a massive reasoning engine for an enterprise, Gemma 4 provides the architectural flexibility to make it happen.

👇 Let's Connect!

Which model are you planning to build with? What's your current local AI stack look like? Let's discuss in the comments!

🚀 Building Smarter with Google Cloud

Tanush — Wed, 29 Apr 2026 04:39:27 +0000

🚀 From Curiosity to Creation: How Google Cloud NEXT Changed the Way I Think About Building

«“The future isn’t built by those who wait — it’s built by those who experiment.”»

🌩️ My First Step into Google Cloud (and Why It Felt Different)

Before diving into Google Cloud, I used to think cloud platforms were just about storage, servers, and scaling. But when I explored what Google showcased at Google Cloud NEXT, I realized something bigger:

👉 It’s not just infrastructure — it’s intelligence + innovation combined.

What stood out to me wasn’t just the tools, but the philosophy:

«Build faster. Think bigger. Let AI handle the heavy lifting.»

🧠 The Moment That Changed Everything: AI Meets Cloud

The most exciting part of Google Cloud NEXT was how deeply AI is integrated into everything.

We’re not just writing code anymore — we’re collaborating with AI.

Imagine:

Writing backend logic with AI assistance
Deploying apps without worrying about infrastructure
Analyzing huge datasets in seconds

This shift made me realize:

«The developer of today is becoming more of a creator + problem solver, not just a coder.»

⚙️ What I Explored (And Loved)

Here are a few things that genuinely impressed me:

🔹 1. Vertex AI — Your AI Playground

Instead of struggling to build ML models from scratch, Google Cloud gives you a complete ecosystem.

💡 What I tried:

Experimented with prompts
Explored how models can be tuned
Understood how apps can be powered by AI

👉 It felt like having a brain inside my application.

🔹 2. Serverless = Freedom

The idea that I can deploy apps without managing servers blew my mind.

No worrying about:

Scaling
Downtime
Infrastructure setup

Just focus on:

«✨ Building something meaningful»

🔹 3. Real-Time Data Feels Magical

With Google Cloud tools, data isn’t just stored — it’s alive.

You can:

Process streams
Analyze instantly
Make decisions in real-time

And that’s where innovation happens.

🔥 A Small Idea That Became Big

Inspired by what I learned, I thought:

👉 What if I build a smart student assistant using Google Cloud?

Something that:

Answers questions
Helps with notes
Suggests learning paths

Using:

AI models
Cloud functions
Real-time data

That’s when it clicked:

«Google Cloud doesn’t just give tools — it gives possibilities.»

🌍 Why This Matters for Developers Like Us

We’re entering a phase where:

Speed matters
Ideas matter more than resources
Anyone can build something impactful

Google Cloud is lowering the barrier.

You don’t need:

Huge teams
Expensive setups

You just need:

«💡 Curiosity + willingness to try»

🚀 My Biggest Takeaway

After exploring Google Cloud NEXT, one thought stayed with me:

«“Don’t just learn technology. Use it to create something that didn’t exist yesterday.”»

✨ Final Thoughts

Google Cloud NEXT isn’t just an event — it’s a glimpse into the future.

A future where:

AI is your teammate
Cloud is your foundation
And ideas are your only limit

And honestly?

👉 I’m just getting started.

If you're a student or beginner like me — don’t wait to feel ready. Start exploring. The cloud is more accessible than ever.