DEV Community: Aravind d

Gemma 4 CAD Orchestrator

Aravind d — Mon, 25 May 2026 05:43:53 +0000

This is a submission for the Gemma 4 Challenge: Build with Gemma 4

What I Built

Gemma 4 CAD Orchestrator is a cloud-native, AI-powered parametric CAD application that lets engineers describe mechanical parts in plain English and instantly see them rendered in 2D blueprint view and 3D interactive viewport — powered by Google DeepMind's Gemma 4 26B A4B IT via Vertex AI Model Garden.

🎥 Live Demo

🌍 Try the Application:
Gemma 4 CAD Orchestrator Live Demo

🔥 How I Used Gemma 4

🏗️ Engineering the Future of CAD with AI

The Vision

Traditional CAD workflows are powerful — but painfully slow.

Mechanical engineers already visualize components mentally long before they open design software. Yet translating those ideas into production-ready geometry still requires repetitive manual operations.

I wanted to eliminate that friction completely.

The goal was ambitious:

“What if engineers could design mechanical parts exactly the way they think?”

So I built a deterministic text-to-geometry orchestration engine powered by Gemma 4.

A user can type:

Create a mounting plate 100mm long, 60mm wide, 8mm thick with four 10mm bolt holes.

…and within seconds the system generates:

A structured parametric model
A live 3D interactive viewport
A synchronized 2D engineering blueprint
An editable feature tree
Accurate dimensional calculations

No installation.
No workstation-heavy CAD software.
Just AI-native engineering.

🤖 Why Gemma 4?

The hardest challenge wasn't rendering geometry.

It was teaching an LLM to reliably understand engineering intent while producing deterministic JSON structures without hallucinating invalid dimensions or impossible geometry.

Gemma 4 handled this exceptionally well.

Its MoE architecture enabled:

Faster structured generation
Lower inference overhead
Stable schema adherence
High-context engineering interpretation
Strong reasoning across dimensional constraints

To maximize reliability, I built the orchestration layer with a multi-provider cascading architecture.

AI Backend Cascade
Ollama → Local workstation inference fallback (gemma4:31b, gemma4:26b)
Vertex AI Gemma 4 MaaS → Primary production inference engine
Hugging Face Inference API → Serverless resilience layer
Google Gemini API → Operational failover endpoint

The backend automatically detects available providers and gracefully reroutes requests during failures.

3. System Architecture

User Browser Cloud Run Vertex AI
┌──────────────┐ HTTP ┌──────────────────┐ gRPC ┌──────────────────┐
│ Three.js 3D │◄────────────►│ Express Backend │◄────────►│ Gemma 4 26B A4B │
│ Canvas 2D │ /api/* │ @google/genai │ │ MaaS (Global) │
│ Copilot UI │ │ JSON Parser │ │ │
└──────────────┘ │ System Prompt │ └──────────────────┘
└──────────────────┘
│
┌───────▼────────┐
│ google.json │
└────────────────┘

⚡ Operational Pipeline

Intent Capture Users define mechanical concepts directly inside a terminal-style AI Copilot interface.
Contextualization
Middleware injects highly constrained system prompts defining:
Valid geometric primitives
Parametric boundaries
Execution examples
Dimensional validation rules
Typed schema contracts
Inference Execution
Gemma 4 generates deterministic structured payloads containing:
shapeType
params
featureTree
coordinates
engineering explanation
Geometry Translation
The frontend converts the generated schema into live geometry.
Three.js renders the interactive WebGL viewport
HTML5 Canvas produces synchronized orthographic engineering blueprints
Responsive orbit controls enable real-time interaction

5. Key Technical Decisions

Decision	Tactical Benefit
Serverless Cloud Run	Zero cluster overhead, auto-scaling execution to 0, isolated 512MB RAM footprints—ideal for hyper-efficient, cost-conscious microservice hosting.
Pure Client-Side Renders	Leveraged vanilla HTML5 Canvas and native Three.js via CDN. Zero heavy server-side image processing, reducing latency to near real-time.
MoE Routing Constraints	Utilizing the 26B A4B variant routes work to 3.8B active parameters per token, slashing generation times while holding high-level structural intelligence.
Unified `@google/genai` Integration	Erased SDK technical debt by utilizing the new standardized Google SDK, establishing clean async patterns via `ai.models.generateContent()`.

Structured JSON Contracts Guaranteed geometry-safe deterministic outputs
🛠️ Engineering Challenges Solved
🔄 SDK Migration During Development

Mid-development API changes required rebuilding inference routing from legacy model instantiation methods into unified client pipelines.

🌐 Vertex AI MaaS Routing

Debugging global endpoint routing behavior for Model Garden MaaS instances required runtime-level validation and failover engineering.

📦 JSON Conformance Stability

LLMs often break structured output when prompts become highly technical.

I solved this by:

Separating reasoning blocks from payload blocks
Enforcing strict tagged response zones
Designing schema-first prompts
Using deterministic parsing validation

📚 Core Parametric Geometry Library

Primitive	Param 1	Param 2	Param 3	Param 4
plate	length	width	thickness	holeDia
bracket	leg1	leg2	width	thickness
spacer	length	outer	bore	—
block	length	width	height	bore
cube	length	width	height	—
cylinder	radius	height	—	—
sphere	radius	—	—	—
cone	radius1	radius2	height	—
torus	ringRadius	tubeRadius	—	—

🚀 What’s Next
🖼️ Multimodal Blueprint Reconstruction

Gemma 4 already supports multimodal inputs.

The next phase is enabling users to upload:

Whiteboard sketches
Hand-drawn blueprints
Engineering photos

…and automatically reconstruct them into editable CAD geometry.

🏭 Industrial Export Pipelines

Planned support includes:

STEP
STL
DXF
Manufacturing-ready CAD exports
✨ Advanced Geometry Modifiers

Upcoming AI-assisted geometric operations:

Chamfer generation
Fillet computation
Shell modifiers
Parametric edge reconstruction

Snip about my ideas:

🌌 Final Thoughts

Gemma 4 CAD Orchestrator represents more than a hackathon project.

It explores a future where:

Engineers communicate with software naturally
AI understands manufacturable intent
CAD becomes conversational
Design iteration happens instantly

This project combines:

AI reasoning
Cloud-native infrastructure
Real-time rendering
Parametric engineering
Deterministic geometry systems

…into a single AI-native mechanical design workflow.

The future of engineering software won't start with menus.

It will start with language.

Google Just Rebuilt the Search Box (Again) — But This Time It's Different

Aravind d — Mon, 25 May 2026 04:54:12 +0000

This is a submission for the Google I/O Writing Challenge

Google I/O 2026 Writing Challenge

Spark, Omni, and the Agent in Your Pocket

Never in my wildest dreams did I imagine hearing the word "quadrillion" tossed around casually in a tech keynote.

When you look at the sheer velocity of Google I/O 2026, it’s easy to get blinded by the staggering metrics: 3.2 quadrillion tokens processed monthly, 13 platforms clearing a billion users, and 900 million citizens already inside the Gemini ecosystem. But true innovation isn't measured in server racks—it’s measured in human relief.

It’s the comfort of using Gemini to translate chaotic medical jargon after a stressful doctor's visit with aging parents. It’s a frantic parent using Maps to find an emergency clothing store when their kid falls in a muddy puddle 30 minutes before a formal wedding. It's using your voice to spin up a last-minute boardroom presentation while stuck in traffic. When technology bridges those gaps, it stops being a tool and starts being a lifeline.

To the 8.5 million developers building on this engine every month: thank you. You are taking raw intelligence and forging real-world solutions. We have officially entered the agentic era, and the playground is wider than ever.

If you are looking for inspiration for your own writing challenge submission, here is a curated breakdown of the absolute best sessions, updates, and hidden gems that stole the show at Shoreline.

AI Sessions that caught my eye

Here are the AI-focused sessions that stood out:

Session	Why it's interesting
Building agents with real-world reasoning	Production agents for travel/logistics using Gemini 3 + Maps Grounding Lite. LLMs meeting physical-world logic.
Scale AI with Google's TPU software stack	Deep dive into MaxText (pre-training), Tunix (post-training), vLLM (inference) on TPUs with JAX/PyTorch.
Build agents with Gemini API	Fastest path from prompt to production agent using the new Interactions API. Live-coding your own agent.
On-device AI with Google AI Edge & Gemma	MediaPipe Tasks, Gemma, LiteRT — private, low-latency AI across mobile and web.
Build intelligent Android apps with Google's AI	On-device models + cloud reasoning + agentic frameworks for Android. Real-world partner insights.
Agent-first workflows: prompt to production	End-to-end lifecycle to deploy and manage AI-native apps on Google Cloud without leaving your editor.
Chrome DevTools for agents	MCP server + CLI giving coding agents runtime access to inspect, debug, and audit web apps autonomously.
The future of software development	Panel with leads of Gemini, Antigravity, and AI Studio on vibe coding and evolving engineering roles.
Unlock modern web capabilities in AI coding workflows	Chrome bridging the knowledge gap — Modern Web Guidance + Baseline for AI coding agents.
Develop AI agents with Google Workspace	Extend agents into Docs, Chat, and Gmail. Seamless bridge between custom apps and Workspace.
Supercharge Android media with Jetpack Media3 & CameraX	End-to-end media pipeline — capture with CameraX, transform with Media3, play with ExoPlayer.

Android Sessions that caught my eye

Here are the Android sessions that stood out:

Session	Why it's interesting
What's new in Android (PA Keynote)	Android 17 deep dive — Jetpack Compose, desktop/large screen, agentic automation, media/camera, form factors.
What's new in Android development tools (PA Keynote)	Android Studio demos + latest Gemini capabilities for Android app development.
Adaptive development for the expanding Android ecosystem	"Adaptive Everywhere" — phones, cars, TVs, XR. Jetpack Compose across foldables, desktops, ChromeOS.
Build adaptive layouts with Navigation 3	State-driven back stack + scene decorator API for multi-pane adaptive layouts on all window sizes.
Develop faster with AI in Android Studio	Gemini's agentic capabilities across prototyping, testing, maintenance, and workflow integration.
Deploy Android on-device AI with ML Kit GenAI & LiteRT-LM	Gemini Nano on-device + LiteRT-LM for custom models. Privacy-first, offline-capable AI.
Android accessibility updates	TalkBack, Voice Access, dark theme, Android 17 accessibility API changes. Best practices.
Build beautiful, premium, adaptive apps with Material	New Expressive updates to Material Design components, improved customizability.
Supercharge Android media with Jetpack Media3 & CameraX	Capture with CameraX, transform with Media3 Transformer, play with ExoPlayer. AI-powered effects.
The latest in Android XR	Android XR SDK, Jetpack XR Libraries, ARCore Geospatial, AI glasses, XR Emulator.
Migration agent (Preview)	Migrate React Native, web, or iOS code to native Kotlin Android apps in hours instead of weeks.

Chrome Sessions that caught my eye

Here are the Chrome & web sessions that stood out:

Session	Why it's interesting
What's new in Chrome (PA Keynote)	The cutting edge of web development — where Chrome is taking the browser in 2026.
What's new in Web UI (PA Keynote)	Scroll-triggered animations, scoped view transitions, native CSS/HTML primitives. Ship better UIs with less code.
Unlock modern web capabilities in AI coding workflows	Modern Web Guidance + Baseline for AI coding agents. Chrome bridging the knowledge gap.
Supercharge AI coding with Chrome DevTools for agents	DevTools MCP server + CLI. Agents inspect, debug, audit web apps autonomously.
Build your website for the agentic era	WebMCP origin trial, Gemini in Chrome. Prepare pages for AI agents that understand context and trigger actions.
Modernize authentication with passkeys & digital credentials	Phishing-resistant auth. Passkeys, Digital Credentials, Identity Federation.
What's new in Angular	Angular evolving with new features and AI tools. Better productivity and developer ergonomics.
Elevate the Chrome Extensions developer experience	Streamlined Chrome Web Store dashboard + new tooling for extension building.
HTML-in-Canvas API (Origin Trial)	Immersive 3D experiences that stay searchable, accessible, and interactable. Real DOM in WebGL/WebGPU.

What caught your eye from I/O?

Was it Gemini 3.5 Flash — four times faster, half the cost, now the default everywhere? Or Gemini Omni generating video from any input, where physics actually behaves and characters don't morph between shots?

Maybe it was Gemini Spark — a 24/7 background agent running on Google Cloud that watches your credit card statements, plans block parties, and keeps working when your laptop is closed. Or Antigravity 2.0, the agent-first dev platform that lets you orchestrate subagents in parallel like a conductor.

Docs Live turning a stream-of-consciousness voice dump into a structured first draft? Google Pics treating every pixel as an editable object? Project Aura glasses finally landing this fall with Warby Parker and Gentle Monster?

Maybe you just want to vibe-code an Android app in AI Studio and ship it to the Play Store before lunch.

Pick your moment. Write about it. We want to hear your take.

More announcements worth a closer look

A few more highlights from the official I/O recap that didn't fit in the tables above:

Universal Cart — a unified cart spanning Search, Gemini, YouTube, and Gmail that hunts for deals, spots product conflicts, and handles checkout via UCP. Shopping meets agents.
Google Flow Agent & Flow Tools — generate custom creative tools with natural language inside Flow. Design a video effect, build a shader, or remix a template — no code required.
Gemini for Science — three experimental tools (Hypothesis Generation, Computational Discovery with AlphaEvolve, Literature Insights with NotebookLM) plus Science Skills for Antigravity that connect 30+ life science databases.
Project Aura / Android XR glasses — audio glasses from Warby Parker and Gentle Monster arriving this fall, plus display models with live translation, navigation prompts, and notification summaries.
Ask YouTube — conversational search across videos that lands you at the exact timestamp you need.
Google Pics — built on Nano Banana, it treats every element as an individual object. Segment, edit text, translate, and integrate with Workspace.
Neural Expressive redesign — fluid animations, vibrant colors, new typography, and haptic feedback. The Gemini app's entire look and feel was rebuilt from the ground up.
AI Inbox & Gmail Live — smart email triage with auto-generated draft replies, task management, and voice-powered queries rolling out this summer.
SynthID everywhere — invisible watermarking verification now built into Chrome and Search, not just the Gemini app.
Build with Gemini XPRIZE Hackathon — $2 million prize pool, the biggest hackathon purse ever. Your chance to build something that matters.

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.