DEV Community: Aravind d

Git_TerraCLI

Aravind d — Mon, 16 Feb 2026 05:25:23 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

Automating the boring stuff: I built a Copilot CLI Agent that automatically refactors Terraform deprecations and opens Pull Requests using the Model Context Protocol (MCP).

No more manual upgrades. No more missed warnings. No more broken pipelines.

This solution integrates:

GitHub Copilot CLI Agent (custom-named “copilot”)
Terraform MCP Server
Azure DevOps Pipelines
Automatic PR creation in Azure Repos
Continuous azurerm provider maintenance

The result: Infrastructure maintenance becomes autonomous.

🧩 The Problem

Terraform projects — especially those using the Azure provider — accumulate technical debt fast.

Every new release of the HashiCorp azurerm provider introduces:

Deprecated resources
Renamed arguments
Behavioral changes
Breaking updates
Plan failures over time

Manually fixing these across dozens of .tf files is:

❌ Time-consuming
❌ Error-prone
❌ Often postponed
❌ Risky in production

💡 The Solution

I engineered a fully autonomous remediation agent that:

Detects outdated provider versions
Upgrades azurerm to the latest compatible version
Runs Terraform plan
Uses MCP to fetch exact replacements for deprecated fields
Refactors code safely
Validates changes
Creates a Pull Request automatically

All inside an Azure Pipeline — with zero human intervention.

My Experience with GitHub Copilot CLI

Using the GitHub Copilot CLI in agent mode was transformative.

Instead of just generating code snippets, Copilot acted as:

➡️ An autonomous developer
➡️ A refactoring engine
➡️ A DevOps assistant
➡️ A remediation bot

What impressed me most:

🧩 Context Awareness

The agent understood:
Repository structure
Terraform semantics
Pipeline environment
Required workflow steps

⚡ Speed of Development

Tasks that normally take hours were reduced to minutes:
Writing complex pipeline logic
Handling provider upgrades
Creating PR automation
Integrating MCP

🧠 From Assistant → Agent

This project highlights the shift from AI as a helper to AI as a teammate that executes tasks end-to-end.

This agent enables:

🛡️ Continuous compliance with provider updates
⚡ Faster upgrade cycles
🧹 Reduced technical debt
🤖 Autonomous DevOps operations
🏢 Enterprise scalability

🔮 Future Improvements

Planned enhancements:

Slack / Teams notifications on PR creation
Multi-provider support (AWS, GCP)
Drift detection integration
Security policy checks
Automatic merge on green validation
ChatOps commands to trigger updates

🧪 Key Technologies Used

GitHub Copilot CLI (Agent Mode)
Terraform
Model Context Protocol (MCP)
Azure DevOps Pipelines
Docker
Azure CLI
PowerShell

Snip about the project

pipeline

A QuantuME Portfolio ⚛️🤖

Aravind d — Sun, 01 Feb 2026 17:54:18 +0000

This is a submission for the [New Year, New You Portfolio Challenge Presented by Google AI](https://dev.to/challenges/new-year-new-you-google-ai-2025-12-31

Note: I’m not a frontend developer, but I’m confident this portfolio won’t disappoint—and it reflects how AI will redefine the way engineers build, operate, and collaborate in the future 🚀

(https://aravind-927658424578.us-central1.run.app)

About Me

I’m a Cloud & SRE Engineer with deep expertise across Azure, AWS, and GCP, specializing in automation-first infrastructure, Kubernetes platforms, and AI-driven operations.

I focus on building self-healing, governance-driven, and scalable cloud systems using Terraform, CI/CD pipelines, and agentic AI frameworks. This portfolio reflects how I think as an engineer—starting from fundamentals, scaling through automation, and delivering measurable real-world impact.

Portfolio

Developing a high-impact developer portfolio requires more than just clean HTML; it requires an AgenticAI Experience. In this project, I built Quantum Folio—a developer portfolio—using an ADK (Agentic Development Kit) approach, A2A (Agent-to-Agent) communication, and Dockerized deployment on Google Cloud Run, orchestrated by the Antigravity agentic, Stitch and powered by GeminiCLI.

Guide for Realm

Upon entry, an AI agent named Gravion greets you and helps you explore the portfolio. You can either select from pre-built questions or craft your own prompts—for example: “Tell me about your creator” or “Tell me about your creator’s experience” 💬✨.
The main page highlights skills and experience, while the About section is accessible at the bottom of the interface.

How I Built It

🏗️ ADK Architecture (Agentic Development Kit)
Instead of a static website, this portfolio is built as a modular ADK, allowing new capabilities to be added through independent agents.

🔄 A2A (Agent-to-Agent) Flow

Router Agent – Interprets user intent
Skills Agent – Technical stack and expertise
Experience Agent – Professional journey
Feedback Agent – User feedback and interaction
Quantum Agent – Physics-inspired explanations

This A2A design ensures the right “expert” agent responds every time, improving both UX and scalability ⚙️🧠.

🛠️ The Engine: Antigravity & Gemini CLI
This project wasn’t just coded—it was co-piloted.

Gemini CLI enabled creative reasoning, long-context understanding, agent logic, and domain knowledge.
Antigravity handled infrastructure decisions, Docker configuration, and Cloud Run troubleshooting.

Together, they enabled rapid iteration while maintaining architectural clarity 🚀.

Security

Agentic Security: A2A Rate Limiting

To protect the ADK from abuse, I implemented agent-level rate limiting using a sliding time window:

checkRateLimit(channel) {
const history = this.rateLimits[channel] || [];
const recent = history.filter(ts => Date.now() - ts < 60000);
if (recent.length >= 3) return false; // Security Alert triggered
recent.push(Date.now());
this.rateLimits[channel] = recent;
return true;
}

What I'm Most Proud Of

⚛️ Turning a portfolio into an agentic system, not a static site
🧠 Applying A2A patterns to a real UX problem
☁️ Seamless Cloud Run + Docker deployment
🎨 A unique Quantum Zero-G visual metaphor that reflects modern distributed systems
🚀 Demonstrating how Google AI + agentic tooling can elevate developer experiences

A glimpse into QuantuME Folio

Thanks to Google for providing this opportunity and inspiring me to step outside my comfort zone and learn more about frontend development.

Starlight Storyteller: AI-Powered Sky Explorer

Aravind d — Mon, 15 Sep 2025 05:29:42 +0000

This is a submission for the Google AI Studio Multimodal Challenge

What I Built

I created The Stargazing App — a multimodal web experience that transforms your phone or laptop into a pocket observatory. By simply entering your location and time, you’ll instantly see what the night sky has in store: from twinkling constellations to planets on the horizon. The app blends astronomy data with AI-powered storytelling, so users don’t just see the stars — they understand them. 🌠

Demo

Check out the live demo here → YouTube Demo

How I Used Google AI Studio

Google AI Studio was the heart of Starlight Storyteller, empowering me to harness Gemini 1.5 Flash’s multimodal prowess for a stellar user experience. Here’s how I wielded its magic:

Model Selection 🔍: I chose Gemini 1.5 Flash in Google AI Studio for its text and image processing capabilities, perfect for blending astronomical data with sky map annotations—all within the free tier, keeping costs at zero! 💸

Prompt Engineering ✍️: In AI Studio’s intuitive interface, I crafted a structured prompt to make Gemini an “AstroGuide.” It analyzes JSON data (e.g., {"planets": [{"name": "Jupiter", "ra": 5.91, "dec": 23.13, "alt": 45.0}]}) and sky map images, delivering summaries like: “Jupiter glows at 45° altitude in New York, named for the Roman god-king!” I iterated in Studio to perfect the tone—fun, educational, under 400 words. 🪐📖

Multimodal Testing 🖼️: I uploaded sample PNG sky maps (generated via Matplotlib) to AI Studio, testing how Gemini annotates objects (e.g., “Jupiter is the bright dot at center”). This ensured accurate image-text integration before coding API calls. 🌟

Export to API ⚙️: Once the prompt shone brightly, I exported it as a tuned model ID for Vertex AI. AI Studio’s Python snippets made integration into my FastAPI backend a breeze, using Image.from_bytes to send sky map PNGs to Gemini. 🚀

Validation & Iteration 🔄: AI Studio’s fast feedback loop let me tweak prompts, test outputs, and refine instructions (e.g., handling unclear images by relying on JSON). This slashed debugging time when deploying to Cloud Run. 🛠️

Multimodal Features 🌍📷

Text + Image Fusion: Users provide location/time, and the app generates both a written summary and annotated visuals.

AI-Powered Storytelling: Gemini narrates myths, facts, and tips, turning cold star charts into cosmic stories.

Dynamic Visuals: A PNG sky map is annotated by Gemini, while a D3.js-powered SVG lets users interactively explore the sky.

Smart Reliability: Caching ensures repeat lookups are lightning-fast ⚡, and offline fallbacks mean you’re never lost under the stars.

(https://dev-to-uploads.s3.amazonaws.com/uploads/articles/eij3khdystsuenhit9lv.png)

Final Thoughts 🌌💡

This project taught me how multimodal AI can transform raw data into meaningful human experiences. With Google AI Studio as my creative lab and Gemini as my storytelling partner, I built not just an app — but a stargazing companion for dreamers, learners, and explorers everywhere. 🌙✨

🎙️ Turning Microsoft Teams Meetings into Actionable AI Reports with AssemblyAI 🧠💼

Aravind d — Mon, 28 Jul 2025 04:19:58 +0000

This is a submission for the AssemblyAI Voice Agents Challenge

What I Built

We’ve all been there — back-to-back Microsoft Teams meetings, and by the time one ends, you’ve forgotten the key takeaways from the last. 😅
What if your meetings could summarize themselves?
Well… I built just that. 💡

Instead of manually rewatching recordings or relying on scattered notes, I built an AI-powered automation system that transcribes, analyzes, and summarizes meeting recordings — all thanks to AssemblyAI. 🦾🎧

🚀 Why AssemblyAI Was the Core Engine

AssemblyAI made this project possible. Here's what stood out:

✅ Fast and accurate transcription of long-form audio
✅ Support for punctuation, paragraphing, and timestamps
✅ Easy-to-use API — literally a few lines of Python and I had readable transcripts
✅ LeMUR integration (Language Model for Understanding & Reasoning)

Here’s a code snippet that kicked it all off:

Demo

<-- https://youtu.be/ZqMY-5OZD34 -->

GitHub Repository

<-- https://github.com/AravindFLASH/AssemblyAI/tree/main -->

Technical Implementation & AssemblyAI Integration

🎤 First Attempt: LeMUR by AssemblyAI
I initially tried AssemblyAI’s LeMUR, a brilliant summarization engine that works right after transcription.
It almost felt like magic... until reality hit:

😬 Trial limits on LeMUR meant I couldn’t process full-length recordings.

While the API was intuitive and powerful, the constraints cut the experiment short.

So, I pivoted.

🔁 Switching to Google Gemini for Summarization
To overcome this, I decided to decouple transcription and summarization:

I continued using AssemblyAI for transcription, which is fast and reliable.

Then passed the transcribed text to Google Gemini, a powerful multimodal LLM, to generate structured meeting summaries.

This combo worked well:

AssemblyAI handled speech-to-text conversion.

Gemini extracted key points, decisions, and action items with impressive detail.

📄 A Sample Output Looked Like This:

🔮 What’s Next: Future Deployment Ideas

The vision doesn’t stop here. Here's where I’m taking it:

🤝 Integrate summaries into Azure DevOps to auto-create work items

🧪 Run Sentiment Analysis on meeting tone for feedback culture

🗣️ Use Speaker Diarization to tag “who said what”

📅 Sync with calendar to auto-label topics, agenda, and participants

🌍 Multilingual support for global teams

💬 Final Thoughts

This project is powered by the superb transcription capabilities of AssemblyAI, with a touch of LLM flexibility when needed. 💥
Whether you’re building for productivity, compliance, or just to reclaim your time — this kind of system can be your AI-powered meeting assistant.

🎯 AssemblyAI isn’t just a transcription tool — it’s the brain behind understanding your conversations. 🧠💬

My deepest gratitude to AssemblyAI. Their industry-leading Speech-to-Text API was the essential backbone of our AI-powered meeting report solution, enabling accurate transcription that fuels our Gemini AI analysis. Thank you for empowering our innovation!

No More Surprises: Get Notified on Terraform Deprecations

Aravind d — Sat, 28 Jun 2025 19:54:05 +0000

This is a submission for the Runner H "AI Agent Prompting" Challenge

What I Built :->

Runner AI is a smart assistant designed to proactively monitor Terraform configurations for Azure infrastructure. It works by scanning the official Terraform Registry for all azurerm_* resources—such as azurerm_app_service, azurerm_virtual_machine, and others and intelligently extracting critical annotations like:

⚠️ Warning: Highlights breaking changes, deprecated arguments, or known limitations.

📝 Note: Provides essential usage guidance or edge-case behaviors often missed during development.

Once collected, this metadata is instantly forwarded to a designated Slack channel, keeping your engineering team informed and ready to act—without needing to dig through documentation manually.

Automation AI helps DevOps and SRE teams to:

📣 Stay informed of Terraform provider changes

🔎 Reduce configuration risks and technical debt

🤖 Automate visibility into infrastructure-as-code updates

💬 Foster team-wide awareness via real-time Slack integration

This tool turns passive documentation into active, actionable alerts, ensuring your cloud infrastructure is both compliant and future-ready.

Proff of concept

See the live example in action.

Surfer 2: The Next Generation of Cross-Platform Computer-Use Agents - H Company

We are a frontier AI research company that designs, builds, and deploys cost-efficient agentic AI systems directly into enterprises’ core workflows and processes.

hcompany.ai

Results:

Runner H >
My Prompt:

Slack:

From Terraform Doc:

azurerm_app_service

azurerm_app_service_plan

azurerm_function_app

How I Used Runner H

The Runner H AI offers an interactive experience by dynamically fetching Terraform azurerm provider resources—like azurerm_virtual_machine—extracting critical warnings, notes, and deprecation alerts, and instantly pushing them to Slack for real-time visibility and collaboration."

Use Case & Impact

For Site Reliability Engineers (SREs):
SREs are focused on maintaining reliability, availability, and performance. This helps them by continuously monitoring Terraform azurerm provider changes—especially Note: and Warning: sections that often hint at deprecated features, required configuration changes, or platform limitations. By surfacing these alerts directly in Slack, SREs can act proactively before issues affect production, ensuring high system uptime and avoiding last-minute firefighting.

For DevOps Engineers:
From a DevOps perspective, infrastructure-as-code (IaC) must be accurate, up-to-date, and compliant. This runner AI tool automates the scanning of Terraform documentation to catch critical updates, helping teams avoid misconfigurations during CI/CD runs. It becomes a part of the DevOps feedback loop, improving visibility, reducing human error, and aligning deployments with the latest Azure standards—without requiring constant manual review.

Social Love

(https://dev-to-uploads.s3.amazonaws.com/uploads/articles/yxqbms9c3twvosa192p0.png)

Conclusion:

🤖 What if your Terraform could talk back?

Mine does.

👀 Meet Runner h AI — it reads the docs, catches the warnings, and drops a Slack ping before your pipeline fails.

Thanks :-)

Shoutout to the Runner H and DEV team — building this was a ton of fun and surprisingly useful in real-world scenarios!@runnerH Thanks for this opportunity

Terraform #DevOps #AI #IaC

Future Developments:

Integration with MCP Portals and A2A Automation

I'm planning to integrate Runner AI with Managed Cloud Platforms (MCP) and enable App-to-App (A2A) automation workflows. This will allow seamless error tracking, policy compliance, and infrastructure updates directly from centralized cloud management portals.

Compliance Tagging & Risk Scoring

Automatically tag resources based on detected risk (e.g., high, medium, low) and generate compliance reports for audits.