Forem: Mohammed Maqsood L

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.