DEV Community: Mohammed Maqsood L

AI SRE

Mohammed Maqsood L — Mon, 06 Jul 2026 00:46:39 +0000

Building reliable autonomous workflows in production requires solving three main challenges: API rate-limiting, command safety, and coordination latency.

Here is a quick demo of how 𝗙𝗿𝗮𝗰𝘁𝗮𝗹𝗦𝘄𝗮𝗿𝗺 tackles these constraints through a structured, multi-agent control plane.

𝗪𝗵𝗮𝘁’𝘀 𝗵𝗮𝗽𝗽𝗲𝗻𝗶𝗻𝗴 𝗶𝗻 𝘁𝗵𝗲 𝘃𝗶𝗱𝗲𝗼:

𝗘𝗱𝗴𝗲 𝗖𝗹𝘂𝘀𝘁𝗲𝗿𝗶𝗻𝗴 (𝗪𝗔𝗦𝗠 𝗣𝗢𝗣𝗖𝗡𝗧): Instead of feeding raw alert streams directly to expensive LLMs, a local Zig-compiled WebAssembly engine runs bitwise Hamming distance clustering.

𝗔𝘂𝘁𝗼𝗻𝗼𝗺𝗼𝘂𝘀 𝗗𝗶𝗮𝗴𝗻𝗼𝘀𝘁𝗶𝗰𝘀 & 𝗟𝗶𝘃𝗲 𝗠𝗶𝘁𝗶𝗴𝗮𝘁𝗶𝗼𝗻: We trigger a local disk bloat warning (temp_sys_bloat.log). The SRE agent tree (Commander → Specialist → Parser) parses the directory structure using local MCP tools. Once approved, the agent executes the cleanup, immediately deleting the bloat log on the host filesystem in real-time.

𝗟𝗶𝘃𝗲 𝗔𝗣𝗜 𝗜𝗻𝘁𝗲𝗴𝗿𝗮𝘁𝗶𝗼𝗻 (𝗟𝗼𝗻𝗱𝗼𝗻 𝗧𝗳𝗟): We connect to the public Transport for London (TfL) status API. The bridge fetches 12 active outages (such as overnight line closures) and maps them into independent incident cards.

𝗛𝗶𝗲𝗿𝗮𝗿𝗰𝗵𝗶𝗰𝗮𝗹 𝗦𝘄𝗮𝗿𝗺 𝗧𝗼𝗽𝗼𝗹𝗼𝗴𝘆: Instead of using a single large agent for everything, tasks are delegated down an air-gapped hierarchy. The Parent (Incident Commander) coordinates the overall SRE lifecycle; the Child (Domain Specialist) isolates system errors based on specific domains (Database, Disk, Network); and the Grandchild (MCP Log Parser) executes target diagnostic tools to compile clean context.

𝗣𝗮𝗿𝗮𝗹𝗹𝗲𝗹 𝗦𝘄𝗮𝗿𝗺 𝗘𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻: When dealing with multiple failures, sequential execution slows recovery. By wrapping Mastra workflows in an asynchronous Express gateway, clicking the "Deploy All Parallel Swarms" button triggers concurrent event loops (Promise.all), resuming and resolving all active incidents simultaneously in a single transaction.

𝗛𝘂𝗺𝗮𝗻-𝗶𝗻-𝘁𝗵𝗲-𝗟𝗼𝗼𝗽 𝗖𝗼𝗻𝘁𝗿𝗼𝗹 (𝗛𝗜𝗧𝗟): Autonomous systems shouldn't execute arbitrary commands unchecked. Every dynamically drafted playbook is suspended at an approval gate, presenting SREs with an interactive console to audit, rewrite, or safely approve the mitigation commands before they touch live production infrastructure.

𝗧𝗵𝗶𝘀 𝐢𝐬 𝐚 𝐩𝐫𝐨𝐭𝐨𝐭𝐲𝐩𝐞 𝐫𝐞𝐪𝐮𝐢𝐫𝐢𝐧𝐠 𝐟𝐮𝐫𝐭𝐡𝐞𝐫 𝐫𝐞𝐟𝐢𝐧𝐞𝐦𝐞𝐧𝐭 𝐚𝐧𝐝 𝐬𝐜𝐚𝐥𝐢𝐧𝐠 𝐨𝐩𝐭𝐢𝐦𝐢𝐳𝐚𝐭𝐢𝐨𝐧𝐬, 𝐢𝐭 𝐝𝐞𝐦𝐨𝐧𝐬𝐭𝐫𝐚𝐭𝐞𝐬 𝐭𝐡𝐚𝐭 𝐜𝐨𝐦𝐛𝐢𝐧𝐢𝐧𝐠 𝐬𝐭𝐫𝐮𝐜𝐭𝐮𝐫𝐞𝐝 𝐚𝐠𝐞𝐧𝐭 𝐡𝐢𝐞𝐫𝐚𝐫𝐜𝐡𝐢𝐞𝐬, 𝐝𝐞𝐭𝐞𝐫𝐦𝐢𝐧𝐢𝐬𝐭𝐢𝐜 𝐩𝐫𝐞-𝐟𝐢𝐥𝐭𝐞𝐫𝐬 (𝐥𝐢𝐤𝐞 𝐖𝐞𝐛𝐀𝐬𝐬𝐞𝐦𝐛𝐥𝐲), 𝐚𝐧𝐝 𝐬𝐭𝐫𝐢𝐜𝐭 𝐬𝐚𝐟𝐞𝐭𝐲 𝐠𝐚𝐭𝐞𝐬 𝐢𝐬 𝐚 𝐡𝐢𝐠𝐡𝐥𝐲 𝐞𝐟𝐟𝐞𝐜𝐭𝐢𝐯𝐞 𝐩𝐚𝐭𝐭𝐞𝐫𝐧 𝐟𝐨𝐫 𝐦𝐚𝐱𝐢𝐦𝐢𝐳𝐢𝐧𝐠 𝐋𝐋𝐌 𝐜𝐚𝐩𝐚𝐛𝐢𝐥𝐢𝐭𝐢𝐞𝐬 𝐰𝐡𝐢𝐥𝐞 𝐦𝐚𝐢𝐧𝐭𝐚𝐢𝐧𝐢𝐧𝐠 𝐜𝐨𝐧𝐭𝐫𝐨𝐥.

This is a submission for the DEV April Fools Challenge

Mohammed Maqsood L — Mon, 06 Apr 2026 22:22:52 +0000

This is a submission for the DEV April Fools Challenge

What I Built
The Sentient Teapot (HTCPCP-Compliant AI Agent) ☕🤖 I took the internet’s oldest joke—RFC 2324 (Hyper Text Coffee Pot Control Protocol)—and gave it a brain. While the original spec defined the legendary 418 I'm a Teapot error, my version uses Gemini 2.5 Flash to actually analyze your "brew request."

If you try to "brew" coffee, the teapot evaluates the "vibes" of your situation, refuses to help (as a teapot should), and writes a custom, algorithmically-generated poem roasting your life choices.

Demo
🚀 Live Dashboard: https://height-being-lloyd-warning.trycloudflare.com/view/teapot-agent/

How I Built It
I wanted this "useless" project to have a "Grade-A" production heart.

AI Brain: Google Gemini 2.5 Flash for the "Vibe Analysis" and "Poetic Refusal."
Architecture: Built on a modular Fractal Kernel (Node.js) where features are self-discovering "Agents."
Infrastructure: Hosted on GCP Compute Engine (e2-micro) for 24/7 "Always-On" refusal.
Persistence: Local PostgreSQL instance on the VM to track every failed "brew" in a global ledger.
Security: Locked down with Cloudflare Tunnels (obfuscating the origin) and a GCP Firewall that only allows traffic from the Cloudflare edge.
Process Management: Handled by PM2 with systemd auto-restart.
Prize Category
Best Google AI Usage: For using Gemini 2.5 Flash to bring logic and sass to an ancient HTTP status code.
Best Ode to Larry Masinter: I’ve fully implemented the HTCPCP headers (x-vibe-context) and strict 418 status code compliance. Larry would be... well, he'd be something.

How "Vibe Coding" Turned a Non-Coder into a Kernel Architect

Mohammed Maqsood L — Sat, 28 Mar 2026 19:48:11 +0000

This is a submission for the 2026 WeCoded Challenge: Echoes of Experience

The "Not Technical Enough" Trap

For years, I believed I was on the outside looking in. I didn't have a Computer Science degree. I didn't spend my teens memorizing algorithms or fighting with pointers. When I looked at traditional codebases, all I saw was a wall of syntax—a gatekeeper designed to keep people like me out.

But in 2026, those gates have fallen.

My Journey: From "Coding" to "System Direction"

My path wasn't linear. It started with a "vibe." I had ideas for complex, multi-tenant systems, but my hands couldn't keep up with my brain. Traditional coding felt like trying to write a novel by carving letters into stone.

Then came the era of AI Agents. I stopped trying to be a "writer of code" and started being a Director of Architecture. I realized that my value wasn't in knowing where the semicolon went, but in knowing how the data should flow.

⚠️ The Overload: When Agents Got "Too Fast"

As I built Shortshub, I hit a wall. AI agents generate code faster than humans can map it. I was drowning in "architectural drift." The agents were hallucinating global states and breaking dependencies because the codebase was too "tangled."

I almost quit, thinking the skeptics were right—that you need a traditional degree to handle this level of complexity.

The Triumph: The Fractal Kernel

Instead of quitting, I leaned into the vibe. I realized that if the AI was hallucinating, it was because my instructions (the codebase structure) were unclear.

I spent weeks architecting the Fractal Kernel. I stopped thinking about "Apps" and started thinking about "Instructions." I decoupled everything into isolated "cells" governed by manifests.

See it in Action: The Control Plane (Port 5004)

Below is a demo of the Runtime Kill-Switch. If an AI-generated feature throws an error, I don't roll back the build. I toggle it "OFF" instantly from a decoupled plane.

The Lesson: Architecture > Syntax

The biggest lesson I’ve learned is this: Engineering is a way of thinking, not a set of syntax rules.

To the underrepresented voices, the self-taught builders, and the people who feel "not technical enough": Your ability to think in systems is more valuable than your ability to debug a bracket. AI has removed the syntax barrier, but it has raised the bar for Intent and Architecture.

🚀 Explore the Kernel

Check out the experiment and the live production site below:

Maqsood32595 / fractal-kernel

A manifest-driven feature architecture for Node.js. Designed to keep AI agents focused and codebases maintainable as they grow.

Fractal Kernel

A manifest-driven feature architecture for Node.js + Express, designed to work cleanly with AI coding agents.

Note: This is a pattern extracted from a personal production project. It is not academically validated. It worked well for me — I'm sharing it to get feedback.

The Problem

When building with AI agents, codebases tend to hit a wall around feature 8-15. The AI starts breaking existing code while adding new features, because it has to read the entire codebase to understand context. As the project grows, the signal-to-noise ratio drops and mistakes increase.

How This Helps

Features are isolated into self-contained folders. A central Kernel auto-discovers and mounts them. The AI only needs to work inside one folder per task — it cannot accidentally touch code it shouldn't.

server/
├── kernel.js                        ← Never modify this
├── index.js                         ← Never modify this
└── features/
    ├── auth/
    │   ├── feature.manifest.json    ←

…

View on GitHub

Live at: www.shortshub.app

Orchestrating AI Velocity: Building a Decoupled Control Plane for Agentic Development

Mohammed Maqsood L — Wed, 25 Mar 2026 22:27:02 +0000

"Building code is only half the battle; maintaining it is the other half."

Working with AI agents in 2026 means code is generated faster than our human "architectural map" can often keep up. Last month, I noticed my project, Shortshub, was suffering from "architectural drift" because agents didn't have a clear boundary of where one feature ended and another began.

To solve this, I’ve moved away from standard monolithic structures and built a fully decoupled Control Plane (running on port 5004). Here’s the breakdown of my experimental "Fractal Kernel" approach. Check the video below.

The Problem: The "Hallucination Spread"
When an AI agent has too much context, it starts making "creative" (wrong) assumptions about global state. When it has too little, it breaks dependencies. I wanted a way to give agents exactly the context they need and nothing more.

Core Architectural Pillars
1. The Fractal Kernel Manifest (Experimental)
The foundation of the repo. Every feature lives in its own "cell" with a strict .manifest file.

How it works: The Kernel auto-discovers these at boot.

The Goal: It makes the codebase "Agent-Native." Instead of scanning 100 files, the agent reads one manifest to understand the "cell" boundaries. (Working may be 80%).

2. The Runtime Kill-Switch (Modular Isolation)
This is my favorite "safety" feature. Features are organized into toggleable Feature Cards.

The Value: If an AI-generated feature throws a hallucinated error in production, I don't have to roll back the whole build. I toggle that specific feature "OFF" from the Control Plane instantly. (Working 70%).

3. Debug Memory & Dependency Graphs
I’m attempting to log common agent errors into a dedicated panel to feed that "debug path" back into the next prompt.

Architecture Log: Working on a visual graph to show how Fractal cells connect (Not working currently).

Debug Memory: Useful about 50% of the time for preventing repetitive logic errors. (Working 50% of the time)

I’m building this using primarily Free-Tier LLM models. The goal is to see if Context Engineering (structuring the repo for the AI) can beat Model Raw Power.

Token Optimization: High. Agents only "see" relevant feature folders.

Speed: High. Features are built in isolation, then "plugged" into the Kernel but there are limits.

Disclaimer & Open Source
This is highly experimental "Vibe Coding" tempered by structural guardrails. I’m looking for feedback from anyone working on Multi-Agent Orchestration or Micro-frontend patterns.

Check out the demo website: www.shortshub.app
Poke the code on GitHub: Maqsood32595/fractal-kernel
Any feedback, interaction, suggestions are welcome.