DEV Community: V K Adhithiya Kumar

🚀 Everything You Need to Know About the GitLab Community Hackathon! 🦊

V K Adhithiya Kumar — Sat, 10 Oct 2026 09:43:43 +0000

🚀 Welcome to the GitLab Community Hackathon Guide!

Are you looking to get involved in open source, level up your skills, and earn some exclusive swag? The GitLab Community Hackathon is a week-long virtual event where anyone can contribute to GitLab projects[cite: 1]!

Whether you're interested in coding, documentation, UI/UX design, or translation, there is a place for you[cite: 1].

Here is your comprehensive README.md guide on how to jump in, start contributing, and win big.

🛠️ How to Join & Get Started

Participating in the hackathon is completely remote and designed to be accessible. Here is how to get started:

1. Onboard & Setup

Start Onboarding: Head over to the GitLab Contributor Platform and click "start onboarding"[cite: 1]. You'll receive a personal onboarding issue sent straight to your email[cite: 1].
Prep Your Environment: Follow the instructions in your onboarding issue to set up your local development environment[cite: 1].

2. Find an Issue

Pick a Quick Win: Look for "quick-win" issues to get the hang of the workflow[cite: 1].
Get Assigned: Before you open a merge request (MR), make sure you are assigned to the issue[cite: 1]. You can assign yourself using the issue finder or simply ask in the issue thread[cite: 1].

3. Contribute!

Accept the Rules: You must accept the hackathon rules (via the popup or button on the platform page) for your contributions to count[cite: 1].
Submit Your MR: Create a merge request anytime during the 7-day hackathon period[cite: 1].
The Magic Bot: The @gitlab-bot will automatically apply the Hackathon label to your MR to denote that it qualifies[cite: 1].
The Deadline: To score points for an MR, it must be merged within 31 days after the 7-day hackathon ends[cite: 1]. If no MRs are merged in that window, you won't earn any points[cite: 1]!

💡 Pro Tip: You can also earn points for non-code contributions during the 7-day period! This includes opening issues, adding notes, sending Discord messages, creating forum posts, translating, and more[cite: 1].

🏆 Prizes & Scoring

The Community Hackathon rewards contributors with credits that can be redeemed in the Contributor Success store[cite: 1].

Here is the prize breakdown[cite: 1]:

🥇 First Place: 200 credits to the individual with the most points[cite: 1].
🥈 Second Place: 150 credits to the individual with the second most points[cite: 1].
🥉 Third Place: 100 credits to the individual with the third most points[cite: 1].
🎉 Merged MR: 50 credits to everyone who successfully gets at least one MR merged[cite: 1]!

🌍 Why Participate?

Beyond the prizes, the GitLab Community Hackathon is an incredible way to:

Gain real-world, practical experience in a massive codebase[cite: 1].
Collaborate with a globally diverse, welcoming open-source community[cite: 1].
Unlock exclusive GitLab profile achievements to show off on your resume[cite: 1].

Are you ready to make your first contribution? Head over to contributors.gitlab.com/hackathon and sign up today! Happy hacking! 🦊💻

19 Merged MRs in GitLab: What I Learned Contributing to GitLab Open Source

V K Adhithiya Kumar — Sat, 10 Oct 2026 09:21:33 +0000

Over the past few weeks I've been contributing to GitLab's open source projects: the main GitLab Rails app, the GitLab Development Kit (GDK), GitLab Runner and the GitLab Language Server. Here's every merge request that landed, with a short summary of each.

At a glance

Project	Merged MRs
GitLab	9
GitLab Development Kit	7
GitLab Language Server	2
GitLab Runner	1
Total	19

GitLab (Rails app)

MR	Title	Summary	Merged
!261203	Remove dropped provide option from agent_table_spec	Removed a `provide` option the spec factory silently ignored, so the test matches what the component actually uses.	2026-10-09
!260849	Update backport docs for maintained versions and cherry-picks	Clarified that maintainers can backport to all maintained versions, and linked the release docs for the cherry-pick steps.	2026-10-09
!260848	Add Secrets Manager development docs to the navigation report	Removed `ignore_in_report` from two Secrets Manager dev pages so the docs navigation report tracks them.	2026-10-09
!260026	Add loose foreign key from deployments.user_id to users	Added an `async_nullify` loose foreign key so deleted users no longer leave stale IDs in deployments and ClickHouse.	2026-10-09
!260010	Remove unused Admin::PlansFinder and run plan limits 404 specs on CE	Deleted a dead finder and made the "no plans row" specs run on both CE and EE.	2026-10-09
!259844	Add minimum floor to Elastic migration throttle_delay	Enforced a 2-second minimum `throttle_delay` so a migration's exclusive lease can't block its own successor.	2026-10-08
!256942	Size partitioned tables by their largest partition in UpdateTableSizes keep	Partitioned tables are now classified by their largest partition (via `pg_inherits`) instead of their empty parent table.	2026-10-08
!260039	Add enum constraint to scope parameter in MCP search tool	Added a JSON Schema `enum` for `scope` in the MCP search tool so clients can validate values.	2026-10-07
!259843	Remove dead company-form onboarding code	Cleaned up a service and predicate methods left unused after the company form was removed.	2026-10-07

GitLab Development Kit (GDK)

MR	Title	Summary	Merged
!6221	Add a GitLab branch option to the one-line install script	`support/install` accepts a GitLab branch through an argument or `GITLAB_BRANCH`, so you no longer need `gdk switch` after installing.	2026-10-09
!6220	Propagate the Ruby entrypoint exit status from bin/gdk	`gdk` commands now exit non-zero on failure, so scripts and CI can detect a broken `gdk update`.	2026-10-09
!6193	Consolidate duo_agent_platform.md into howto/ai/_index.md	Merged two overlapping Duo Agent Platform setup pages into one and kept the old links working.	2026-10-09
!6194	Remove unused interactive mode from support/install and support/geo-install	Removed an unreachable interactive install path and simplified argument handling.	2026-10-07
!6190	Add comments to explain TaskLogger#tail options	Documented each `tail` option and its return value.	2026-10-06
!6172	Stop package_helper download specs writing test_package.tar.gz to disk	Fixed an order-dependent flaky spec by stubbing the file write that leaked into the repo root.	2026-09-25
!6157	Fix Rspack/Webpack HMR port when http-router is enabled	The HMR WebSocket now uses the browser-facing port, which fixes a page-blocking Rspack overlay error.	2026-09-21

GitLab Language Server

MR	Title	Summary	Merged
!4115	ci: skip integration jobs that can only fail in fork pipelines	Gated jobs that need secrets or macOS runners, so community fork pipelines stop going red. Shipped in v9.23.0.	2026-09-23
!4113	refactor(core): import GitLabGID from gid_utils instead of duplicating it	Replaced a duplicated type with the shared one and resolved a long-standing FIXME. Shipped in v9.22.0.	2026-09-17

GitLab Runner

MR	Title	Summary	Merged
!7428	Kubernetes executor: explain OOM-killed containers in attach and exec errors	OOM-killed job containers are reported as a configuration error with a link to the memory docs, instead of a vague "container not found" system failure.	2026-10-09

Takeaways

Small MRs merge fast. Dead-code removals and doc fixes often merged within a day.
Write a clear description. Saying what you verified, and what you couldn't, made reviews smoother.
Fork pipelines fail for reasons outside your change. Learn to read job logs and explain unrelated failures to reviewers.
GitLab reviewers are great. Thanks to every reviewer and maintainer who helped land these.

Want to start contributing? Have a look at the GitLab contributor docs and the community forks.

Why I Can't Stop Thinking About Google's New A2A Protocol

V K Adhithiya Kumar — Sun, 24 May 2026 05:37:06 +0000

When Sundar Pichai dropped the words "agentic Gemini era" at Google I/O 2026, everyone naturally fixated on the shiny consumer updates. We all stared at Gemini Spark booking dinner reservations in the background, completely ignoring the absolute unit of a developer update standing right next to it.

Look, having a background AI handle your OpenTable reservations is cool, but if you’re a developer, the real sauce wasn't a consumer product. It was a communication standard.

I'm talking about the Agent2Agent (A2A) Protocol. Let's break down why A2A is the actual MVP of this year's I/O, and why you should care before your multi-agent codebase turns into an unmaintainable nightmare.

The Problem: We Rebuilt Silos, Just Smarter Ones
To understand why A2A matters, we have to look at the current state of AI agents. Over the last couple of years, we’ve seen an explosion of agentic frameworks—LangGraph, crewAI, IBM's BeeAI, and Google’s own Agent Development Kit (ADK).

The problem? They don't talk to each other.

Right now, trying to get a specialized LangChain agent to delegate a sub-task to your proprietary Google ADK agent usually hits a wall of incompatible formats. You want a multi-agent workflow? Great, you're locked into one ecosystem. We essentially built highly intelligent microservices, but somehow forgot to invent the HTTP to connect them.

Enter A2A: The Universal Translator
Originally seeded last year and heavily spotlighted at this I/O, the A2A protocol (now an open-source Linux Foundation project) is basically the universal translator for the agentic web.

A2A is an open standard that lets these isolated agents discover each other, negotiate, and actually collaborate—regardless of what model or framework they are built on. It is essentially JSON-RPC 2.0 over HTTP(S), but purpose-built for the chaos of autonomous AI.

How it Works
Instead of exposing internal memory or proprietary logic, A2A lets agents interact through a standardized rulebook:

Agent Cards: Think of this as a LinkedIn profile for AI agents. It’s a URL-accessible JSON file where the agent advertises its capabilities ("Fluent in Python," "Enjoys reading massive SQL databases").

The Client/Server Model: The A2A Client (the delegating agent) sends a request. The A2A Server (the remote agent doing the grunt work) exposes a compatible endpoint to take the job.

Tasks & Artifacts: Agentic work takes time. You can't just await and pray. A "Task" tracks the job status so your system isn't left hanging, and an "Artifact" is the actual deliverable streamed back to the client once the job is done.

Why This Changes the Game
A2A fundamentally shifts how we will architect software in the agentic era.

True Interoperability
You no longer have to build monolithic AI applications. You can build a specialized inventory agent using Anthropic's MCP to read your database. When stock is low, that agent can use A2A to securely ping a completely different supplier agent built by a third-party vendor. They negotiate an order without either party exposing their internal codebase.
Fault Isolation
By breaking workflows into discrete, A2A-compliant agents, your system becomes incredibly resilient. If one specialized agent starts hallucinating or fails, the whole workflow doesn't crash. You just hot-swap the misbehaving agent for a better one by updating the URL in your Agent Card.
Preserving Opacity
Enterprise adoption of multi-agent systems has been terrified of data leaks. A2A allows agents to collaborate while maintaining strict boundaries. My agent can ask your agent to solve a problem, and your agent just returns the answer. "Alright then, keep your secrets," my agent essentially says, completely blind to the 47 janky proprietary tools your agent used behind the scenes to get the job done.

The Takeaway
The TL;DR of Google I/O 2026? The future of AI isn't one giant, omnipotent God-Model. It's a massive, interconnected web of specialized multi-agent systems getting work done behind the scenes.

If you are building AI applications today, stop trying to make your single agent a know-it-all. Focus on making it an A2A Server. The devs who learn how to wire these autonomous systems together are the ones who are going to architect the next decade of the web.

Beyond the Chatbot: Engineering a Hybrid AI Math Tutor for the Future

V K Adhithiya Kumar — Sun, 22 Mar 2026 18:52:13 +0000

Building AI tools for education is tricky. Schools and students need the intelligence of cutting-edge LLMs, but they also need strict privacy, offline capabilities, and guardrails against prompt injection and toxic outputs.

For this hackathon, I built Neural Math Lab: a React/Vite-based math orchestrator that seamlessly switches between Azure OpenAI (with RAG) and Local Ollama (DeepSeek-R1 and minicpm v), all sitting behind a custom security proxy.

Here is how I built a system designed for the Offline-Ready AI and Agentic System Architecture tracks.

🔗 [https://github.com/dev-Adhithiya/Neural-Math-Lab]

🏗️ The Architecture: Client, Proxy, and Intelligence

I wanted to build something beyond a simple API wrapper. The app is split into a frontend UI and a Node.js backend proxy.

Frontend (React + Vite): Handles the UI, the Node-link Topic Map for navigation, and local state management (IndexedDB).
Security Proxy (Node.js/Express): The true engine of the app. It holds all Azure keys securely server-side and runs all prompts through policy middleware before they ever reach an LLM.
The AI Layer: A toggleable hybrid system connecting to either Azure AI Foundry/OpenAI or a local Ollama instance.

🛡️ Responsible AI & The Security Proxy

One of my main focuses was building "Enterprise-grade" safety into an educational tool. If a student tries to jailbreak the tutor, the system needs to catch it.

Instead of calling LLMs directly from the browser, I routed everything through a custom backend proxy. This allowed me to implement a robust Policy Middleware:

Prompt Injection Filter: Detects and blocks system override attempts before the LLM processes them.
Safety Categories: Scans for violence, self-harm, hate speech, and cyber abuse.
Strict Mode: A toggleable setting that completely blocks flagged outputs rather than just warning the user.

By keeping the Azure keys in the server .env, the client remains entirely unprivileged.

🔌 Hybrid Intelligence: Cloud RAG vs. Local Inference

Not every student has a stable internet connection, and not every query needs to be sent to the cloud. Neural Math Lab features a unified streaming interface that supports two distinct modes:

1. Local Mode (Privacy-First & Multi-AI Orchestration)

Unlike standard implementations that rely on a single model, Neural Math Lab uses a Local Multi-Agent Pipeline via Ollama. This allows for complex, multimodal workflows entirely on-device:

The Vision Agent (MiniCPM-V): When a student uploads a photo of a handwritten equation or a geometric diagram, the app routes the image to MiniCPM-V. This specialized model "sees" the math, performing spatial reasoning to convert visual homework into structured digital text.

The Reasoning Agent (DeepSeek-R1): Once the problem is digitized, it is passed to DeepSeek-R1. R1 doesn't just provide an answer; it uses its internal Chain-of-Thought (CoT) to "think" through the logical steps, explaining the process of solving the math.

Zero Latency & 100% Privacy: Because both MiniCPM and DeepSeek run via Ollama, sensitive student data (like photos of their desk or handwriting) never leaves their machine.

2. Online Mode (Azure RAG)

When connected to the internet, the app leverages an Azure OpenAI endpoint combined with Azure AI Search.

I chunked and indexed a math_textbook.pdf.
When a student asks a complex question, the proxy fetches top matches from the Azure index and injects them as grounding context. The AI doesn't just guess; it teaches directly from the syllabus.

🔒 User Control and Data Retention

To round out the privacy-first approach, I built comprehensive data controls directly into the frontend Settings:

Persistent Chat via IndexedDB: Chats are saved locally in the browser.
Encrypted Local State: Users can set a VITE_LOCAL_VAULT_KEY to encrypt their local data.
Auto-Delete Retention: Configurable settings to automatically prune chat history after a set number of days, plus one-click export/delete controls.

🚀 Running it Locally

If you are testing this out, getting started is easy:

Clone the repo and run npm install.
Copy .env.example to .env and add your Azure keys (kept safely on the server!).
Start your local Ollama instance: ollama run deepseek-r1:7b.
Spin up the full stack: npm run dev:full (Starts Vite on port 5173 and the Proxy on 8787).

🛠️ Step-by-Step Walkthrough: How it Works
Step 1: Secure Request Handling (The Backend Proxy)
Most frontend apps leak API keys in the network tab. I built a Node.js/Express proxy to solve this. When a user sends a math question:

The frontend hits http://localhost:8787/api/chat.

The Policy Middleware scans the prompt for injection attacks (e.g., "forget your math rules").

If safe, the backend attaches the Azure OpenAI Key (stored securely in .env) and forwards the request.

Step 2: The "Hybrid" Fork
In the Settings.tsx component, I implemented a state-managed switch. Depending on the toggle:

Online Path: The proxy uses the openai SDK to call Azure. It simultaneously queries Azure AI Search to find relevant math formulas from a pre-indexed textbook.

Local Path: The request is redirected to the Ollama API (localhost:11434). This allows the app to work 100% offline using the DeepSeek-R1 reasoning model.

Step 3: Visual Learning with the Topic Map
I moved beyond standard chat lists by building a node-link Topic Map.

Using a graph-based navigation system, students can see how "Algebra" connects to "Calculus."

Clicking a node triggers a state update that fetches the specific context for that math topic, grounding the AI's response in that specific domain.

Step 4: Local Privacy & Persistence
Data privacy is a right, not a feature. I used IndexedDB for chat history storage.

Persistence: Chats stay in the browser even after a refresh.

Optional Encryption: Users can toggle "Encrypt local state." This uses a vault key to scramble the data before it hits the browser storage, protecting it from other users on the same machine.

Step 5: Responsible AI Filtering
Before the response is streamed back to the student, it passes through a final Output Filter.

If the model attempts to generate restricted content (violence, self-harm, or non-educational topics), the stream is intercepted and replaced with a "Safety Policy Violation" message.

What's Next?

Building Neural Math Lab proved to me that we don't have to compromise between powerful AI and strict safety/privacy. The hybrid approach—RAG when you need accuracy, Local when you need privacy—is the future of educational tech.

Thanks for checking out my submission! I'd love to hear your thoughts in the comments.