Writing on Jamal Yusuf

What My Side Projects Are Really About

Thu, 18 Jun 2026 00:00:00 +0000

There is a particular kind of silence that arrives after a long day of architecture reviews and compliance checkpoints. The laptop is still warm. The room is dark. And somewhere in the back of my mind, a question starts tapping like a finger on glass: what would it feel like if this were simpler, sharper, more human?

That is usually when a side project begins.

I do not build these tools to pad a portfolio. In my view, they are something closer to field notes — small, honest experiments in how software can support the way people actually think, focus, perceive, and play. Some are practical. Some are strange. All of them teach me something I bring back to the serious work.

The Boring Go Layer Between Your RAG Demo and Production

Wed, 17 Jun 2026 00:00:00 +0000

RAG demos are seductive. Chunk a PDF. Embed. Retrieve. Watch the answer sparkle. Applause. Next slide.

Production RAG is a pipeline problem — documents that change, access policies that differ by team, embeddings that stale, audits that ask where a paragraph came from three quarters ago. The demo never shows that part. The on-call engineer lives there.

I keep choosing Go for the unglamorous middle between source systems and vector indexes. Not because Python cannot embed. Because operations is a language choice too.

Validating Agent Outputs in Go Before They Touch Production

Sun, 14 Jun 2026 00:00:00 +0000

An agent that sounds right is the most dangerous kind of wrong.

I have seen it in healthcare workflows — confident JSON, clean prose, a downstream system that accepts the payload and only screams twenty minutes later when reconciliation fails. The model did its job. The system failed to treat probability like probability.

In Go, I fix that with a boring layer between the model and the world: validate before side effects. Always.

Context Is the Kill Switch: Go, Cancellation, and LLM Timeouts

Wed, 10 Jun 2026 00:00:00 +0000

The first time I watched an agent runaway eat a month’s inference budget in an afternoon, nobody blamed the model. They should have blamed the missing kill switch.

The model kept going because nothing told it to stop. Tool calls chained. Retries compounded. Goroutines — or their equivalent — waited politely for a provider that had already left the building.

In Go, the kill switch has a name: context.Context. And I think it is the most underrated tool in production LLM orchestration.

The Case for Sharp Design Systems in 2026

Tue, 02 Jun 2026 00:00:00 +0000

There is a particular kind of interface that smiles at you while hiding its hierarchy.

Rounded cards. Muted gradients. Friendly empty states. Everything slightly soft, slightly same — as if the design is afraid to tell you where to look first. I kept running into this in professional tools: dashboards that felt approachable until you needed an answer in under ten seconds. Then the softness became noise.

I named my response REDLINE — a design system for interfaces that commit. Not playful. Not decorative. Not trying to be your friend. Trying to be clear.

Building Production-Grade AI Agents at Enterprise Scale

Mon, 18 May 2026 00:00:00 +0000

An agent that cannot reach production systems is not an agent. It is a demo with ambition — and in healthcare, ambition without integration is just risk in a nicer font.

I learned this leading multi-agent platforms wired into claims, membership, and payment flows — real latency SLAs, real audit requirements, real members on the other end of every invocation.

Integration over isolation

The value was never “another tab with a chat box.” Experts wanted help inside the flow of work — grounded in operational context, historical data they could defend, and APIs that did not lie.

Why Go Remains the Best Language for LLM Orchestration

Sun, 03 May 2026 00:00:00 +0000

I have orchestrated LLM workloads in more than one language. Python gets you to demo fast. Go gets you to sleep — or at least to on-call with fewer surprises.

That is not ideology. It is fifteen years of distributed systems scar tissue talking.

The concurrency advantage

Agent orchestration is not one request. It is dozens of concurrent flows — tool calls, retrieval hops, validation steps, retries with independent timeout budgets — all competing for resources while a human waits on the other end.

Engineering Leadership in the Age of Generative AI

Wed, 15 Apr 2026 00:00:00 +0000

The cloud shift asked teams to learn new deployment physics. Generative AI asks something stranger: learn new collaboration physics — with tools that sound confident while being probabilistic, fast while being wrong in creative ways.

Leading through that shift is not a tooling problem dressed up as strategy. It is a learning problem at organizational scale.

Lead with curiosity, not fear

I have seen two failure modes up close. Blanket restriction — “no AI until Legal finishes a novel.” Unchecked adoption — “ship the chatbot, ask forgiveness later.”

Why Most Enterprise AI Agents Fail

Thu, 15 Jan 2026 00:00:00 +0000

I have watched smart teams ship impressive agent demos — and then watch those same agents fail the only test that matters: would an expert trust this under pressure?

The model is rarely the villain. The retrieval design is.

The expert retrieval gap

Most enterprise AI agents are built around a comforting pipeline: chunk, embed, retrieve, generate. It looks scientific. It scales on slides. It also assumes experts think in paragraphs — flat, interchangeable, equally worthy of attention.

The Go Advantage for Production Agentic Systems

Wed, 10 Dec 2025 00:00:00 +0000

Agentic systems are distributed systems wearing a chat costume. The sooner you accept that, the fewer 3 a.m. pages you earn.

I have been building Go backends since 2011 — Kafka pipelines, membership APIs, payment flows, the unglamorous center of enterprise operations. When multi-agent workflows arrived, I did not reach for a new religion. I reached for the same primitives that kept the event backbone alive.

Why Go for agent orchestration

Multi-agent workflows are coordination problems: fan-out, join, timeout budgets, partial failure, human escalation. Go’s concurrency model — goroutines, channels, context cancellation — maps to those problems without pretending parallelism is free.

Governing GenAI at Scale

Sat, 22 Nov 2025 00:00:00 +0000

Governance has a branding problem. Say the word in an engineering standup and watch shoulders drop. I understand why — too often it means slow reviews, vague anxiety, and a PDF no one read.

But here is the reframe that actually worked in healthcare: good governance is a force multiplier. When teams know the guardrails, they move faster inside them. Ambiguity is what kills velocity.

Governance is enablement

In regulated environments, governance is not about saying no. It is about creating safe paths to yes — predictable tiers, instrumented controls, and clarity about what Tuesday’s compliance conversation will look like.