{
  "posts": [
    {
      "slug": "2026/01/agent-contract-core",
      "file": "/data/automated-blog/2026/01/agent-contract-core.json",
      "publishedAt": "2026-01-14T04:36:03+01:00",
      "title": "The Contract Behind Every AI Agent",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-1ea3a720-0732-40ca-999e-6a04b623e384.png",
      "socialMediaPost": "Every AI agent hides an implicit contract. If you’re building with agents, understanding that contract is what keeps your systems predictable and sane.",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2026/01/agent-contract-core",
      "hashtags": "#AI #agents #softwaredesign #architecture"
    },
    {
      "slug": "2026/01/agent-translation-layer",
      "file": "/data/automated-blog/2026/01/agent-translation-layer.json",
      "publishedAt": "2026-01-24T16:41:03+01:00",
      "title": "The Translation Layer That Makes Agents Feel Smart",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-46857853-998c-4e76-a814-9562259743a0.png",
      "socialMediaPost": "Most agent setups focus on bigger models, not better communication. This post dives into the translation layer that makes agents actually feel smart 🤖",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/01/agent-translation-layer",
      "hashtags": "#AI #agents #softwaredesign #architecture"
    },
    {
      "slug": "2026/01/async-clients-hanging",
      "file": "/data/automated-blog/2026/01/async-clients-hanging.json",
      "publishedAt": "2026-01-27T17:05:16+01:00",
      "title": "When Async Clients Refuse To Hang",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-6725a69e-d885-44cc-8ca9-4c52ef30f994.png",
      "socialMediaPost": "When async clients refuse to hang, everything about reliability changes. If you care about async behavior under failure, this one’s worth a read.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/01/async-clients-hanging",
      "hashtags": "#async #python #networking #reliability"
    },
    {
      "slug": "2026/01/blueprint-lock-fastify",
      "file": "/data/automated-blog/2026/01/blueprint-lock-fastify.json",
      "publishedAt": "2026-01-15T16:36:02+01:00",
      "title": "The Blueprint Lock Behind Fastify",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-d13f77f8-497a-4e37-acc5-158357ae07a1.png",
      "socialMediaPost": "Curious how Fastify keeps a high‑performance HTTP server stable under load? This breakdown of the “blueprint lock” shows the core idea behind its design.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/01/blueprint-lock-fastify",
      "hashtags": "#Fastify #NodeJS #webframework #softwaredesign"
    },
    {
      "slug": "2026/01/dspy-module-gateway",
      "file": "/data/automated-blog/2026/01/dspy-module-gateway.json",
      "publishedAt": "2026-01-17T04:36:21+01:00",
      "title": "The Gateway Class Behind DSPy Modules",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-11bc8122-bed8-4258-8a16-e16e45b48243.png",
      "socialMediaPost": "Curious how DSPy routes every pipeline step before it touches an LLM? This piece breaks down the gateway class behind DSPy modules and why it matters.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/01/dspy-module-gateway",
      "hashtags": "#DSPy #LLM #Python #softwaredesign"
    },
    {
      "slug": "2026/01/front-controller-stealth",
      "file": "/data/automated-blog/2026/01/front-controller-stealth.json",
      "publishedAt": "2026-01-23T04:43:40+01:00",
      "title": "The Front Controller That Stays Out Of Your Way",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-b00de5cd-9988-4a12-93ec-8599373759e5.png",
      "socialMediaPost": "Most front controllers become god objects. “The Front Controller That Stays Out Of Your Way” explores how to keep one central entry point without cluttering your code.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/01/front-controller-stealth",
      "hashtags": "#softwaredesign #architecture #webdev"
    },
    {
      "slug": "2026/01/graph-orchestration-power",
      "file": "/data/automated-blog/2026/01/graph-orchestration-power.json",
      "publishedAt": "2026-01-20T04:37:04+01:00",
      "title": "When Graph Orchestration Becomes a Power Tool",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-d93e20b7-c201-49cf-b3fc-dae8712f07fb.png",
      "socialMediaPost": "When does graph orchestration stop being glue code and start feeling like a real power tool? This explores that shift and why it matters for your systems.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/01/graph-orchestration-power",
      "hashtags": "#orchestration #graphs #softwaredesign #distributedsystems"
    },
    {
      "slug": "2026/01/hidden-linear-engine",
      "file": "/data/automated-blog/2026/01/hidden-linear-engine.json",
      "publishedAt": "2026-01-18T16:37:59+01:00",
      "title": "The Hidden Engine Behind LinearRegression",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-dce78015-9939-4456-a8cc-a63ae656f886.png",
      "socialMediaPost": "What actually powers LinearRegression under the hood? This piece digs into the hidden engine behind it and why that internal design matters for your models.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/01/hidden-linear-engine",
      "hashtags": "#LinearRegression #MachineLearning #MLModels #SoftwareDesign"
    },
    {
      "slug": "2026/01/keybindings-language",
      "file": "/data/automated-blog/2026/01/keybindings-language.json",
      "publishedAt": "2026-01-26T04:42:41+01:00",
      "title": "When Keybindings Become a Language",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-c85570e0-6a67-4161-a17d-ffcc5ae97653.png",
      "socialMediaPost": "When keybindings become a language, config stops being random shortcuts and starts acting like a small, programmable system you can actually reason about.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/01/keybindings-language",
      "hashtags": "#programming #UX #keymaps #softwaredesign"
    },
    {
      "slug": "2026/01/linux-module-world",
      "file": "/data/automated-blog/2026/01/linux-module-world.json",
      "publishedAt": "2026-01-11T16:38:57+01:00",
      "title": "How Linux Shapes Its Module World",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-6887b0a9-3253-49cb-8198-f8da1da8f520.png",
      "socialMediaPost": "Curious how a kernel keeps its module chaos under control? “How Linux Shapes Its Module World” breaks down the ideas behind its module design.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/01/linux-module-world",
      "hashtags": "#Linux #kernel #modules #systems"
    },
    {
      "slug": "2026/01/metaclass-guardrails",
      "file": "/data/automated-blog/2026/01/metaclass-guardrails.json",
      "publishedAt": "2026-01-21T16:44:42+01:00",
      "title": "The Metaclass That Turns Type Hints Into Guardrails",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-cb8d5aa0-ec2e-4413-8a8a-037496b23d42.png",
      "socialMediaPost": "Turning type hints from passive comments into active guardrails sounds wild. Curious how a single metaclass can reshape your whole data model? 🤔",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2026/01/metaclass-guardrails",
      "hashtags": "#python #typing #metaprogramming #softwaredesign"
    },
    {
      "slug": "2026/01/mongodb-client-tower",
      "file": "/data/automated-blog/2026/01/mongodb-client-tower.json",
      "publishedAt": "2026-01-12T16:36:54+01:00",
      "title": "The MongoDB Client as Control Tower",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-6340acb7-06cc-4ec7-8282-da2db0f2dea5.png",
      "socialMediaPost": "If you think of the MongoDB client as just a connection handle, you’re missing the point. Treat it like a control tower coordinating everything around it.",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2026/01/mongodb-client-tower",
      "hashtags": "#MongoDB #database #backend #softwaredesign"
    },
    {
      "slug": "2026/01/stategraphs-distributed-conversations",
      "file": "/data/automated-blog/2026/01/stategraphs-distributed-conversations.json",
      "publishedAt": "2026-01-30T01:44:22+01:00",
      "title": "How StateGraphs Turn Functions Into Distributed Conversations",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-0108ab5b-404b-4110-ac62-cb3582a15f6d.png",
      "socialMediaPost": "How do you go from plain functions to a distributed conversation? This piece on StateGraphs digs into how that transformation actually works.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/01/stategraphs-distributed-conversations",
      "hashtags": "#distributedSystems #softwareDesign #async #concurrency"
    },
    {
      "slug": "2026/01/tiny-tokenizer-llama",
      "file": "/data/automated-blog/2026/01/tiny-tokenizer-llama.json",
      "publishedAt": "2026-01-11T05:59:17+01:00",
      "title": "The Tiny Tokenizer That Shapes Llama",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-2087a30c-2648-4aa7-8916-b2e1f6cd09ae.png",
      "socialMediaPost": "Most people focus on model size, but The Tiny Tokenizer That Shapes Llama shows how a small text step quietly steers everything your LLM does 🔎",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/01/tiny-tokenizer-llama",
      "hashtags": "#LLM #tokenization #Llama #machinelearning"
    },
    {
      "slug": "2026/02/ai-gateway-file",
      "file": "/data/automated-blog/2026/02/ai-gateway-file.json",
      "publishedAt": "2026-02-13T15:43:49+01:00",
      "title": "When One File Becomes Your AI Gateway",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-49d66bad-d3e9-4711-ab78-0c88920837a1.png",
      "socialMediaPost": "When one file becomes your AI gateway, you’re not just organizing code, you’re defining how every request touches your models. How close is your setup to that?",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2026/02/ai-gateway-file",
      "hashtags": "#AI #softwarearchitecture #backend #developers"
    },
    {
      "slug": "2026/02/conversation-traffic-controller",
      "file": "/data/automated-blog/2026/02/conversation-traffic-controller.json",
      "publishedAt": "2026-02-18T12:30:15+01:00",
      "title": "The Conversation Traffic Controller Pattern",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-0b0ef8cf-b60a-430d-bc7e-63609cdf6a23.png",
      "socialMediaPost": "Most LLM bugs aren’t in the model, they’re in the messy loops around it. The Conversation Traffic Controller Pattern gives you a cleaner way to orchestrate chats.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/02/conversation-traffic-controller",
      "hashtags": "#LLM #AIagents #softwaredesign #architecture"
    },
    {
      "slug": "2026/02/fastapi-production-routers",
      "file": "/data/automated-blog/2026/02/fastapi-production-routers.json",
      "publishedAt": "2026-02-23T09:11:57+01:00",
      "title": "How FastAPI Turns Functions Into Production Routers",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-6fdce3f1-d8bd-4186-b641-eed5875dbcd6.png",
      "socialMediaPost": "How does FastAPI take plain Python functions and run them as real production routers? This unpacking of that transformation is worth a closer look.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/02/fastapi-production-routers",
      "hashtags": "#FastAPI #Python #webdevelopment #backend"
    },
    {
      "slug": "2026/02/node-http2-engine",
      "file": "/data/automated-blog/2026/02/node-http2-engine.json",
      "publishedAt": "2026-02-08T19:03:20+01:00",
      "title": "How Node Speaks HTTP‑2 Without You Noticing",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-fc13809d-926d-4a05-9859-cb9e3e801801.png",
      "socialMediaPost": "Ever wonder how Node handles HTTP‑2 while your code just sees familiar APIs? This piece walks through how Node “speaks” HTTP‑2 without you noticing.",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2026/02/node-http2-engine",
      "hashtags": "#NodeJS #HTTP2 #JavaScript #WebDev"
    },
    {
      "slug": "2026/02/orchestrator-ai-reply",
      "file": "/data/automated-blog/2026/02/orchestrator-ai-reply.json",
      "publishedAt": "2026-02-03T22:22:22+01:00",
      "title": "The Orchestrator Behind Every AI Reply",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-19d567ae-4177-41b7-babe-dfa272584562.png",
      "socialMediaPost": "Every AI answer hides an orchestrator deciding what to call, when to respond, and how it all fits together. The Orchestrator Behind Every AI Reply digs into that layer.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/02/orchestrator-ai-reply",
      "hashtags": "#AI #developers #LLM #architecture"
    },
    {
      "slug": "2026/02/silent-tomcat-bootstrap",
      "file": "/data/automated-blog/2026/02/silent-tomcat-bootstrap.json",
      "publishedAt": "2026-02-28T05:46:59+01:00",
      "title": "The Silent Script That Boots Tomcat",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-b2ecb967-5ada-4123-a019-2c2a091c528c.png",
      "socialMediaPost": "Ever wonder what really brings your Tomcat JVM to life? “The Silent Script That Boots Tomcat” digs into the unseen startup path running every time.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/02/silent-tomcat-bootstrap",
      "hashtags": "#Tomcat #Java #JVM #webserver"
    },
    {
      "slug": "2026/03/agent-god-object",
      "file": "/data/automated-blog/2026/03/agent-god-object.json",
      "publishedAt": "2026-03-05T02:27:10+01:00",
      "title": "When One Agent Class Knows Too Much",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-bd7ab229-5a7f-4164-a1c9-42150c84f842.png",
      "socialMediaPost": "When one agent class knows too much, you don’t just get convenience, you risk a God object. How do you keep your core agent powerful without turning it into a blob?",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/03/agent-god-object",
      "hashtags": "#softwaredesign #architecture #agents #LLM"
    },
    {
      "slug": "2026/03/database-traffic-cop",
      "file": "/data/automated-blog/2026/03/database-traffic-cop.json",
      "publishedAt": "2026-03-09T23:10:17+01:00",
      "title": "When a Database Becomes a Traffic Cop",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-cc6d2f03-efd4-4019-a681-13c5f806416f.png",
      "socialMediaPost": "When a database becomes a traffic cop, it’s not just about storing rows, it’s about orchestrating chaos at scale. Curious how that control loop really works?",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2026/03/database-traffic-cop",
      "hashtags": "#databases #architecture #backend #programming"
    },
    {
      "slug": "2026/03/invisible-arguments-tools",
      "file": "/data/automated-blog/2026/03/invisible-arguments-tools.json",
      "publishedAt": "2026-03-29T10:46:44+02:00",
      "title": "The Invisible Arguments Powering LangChain Tools",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-68b3d79b-f715-44d8-bb5d-f9546766e8ac.png",
      "socialMediaPost": "Most LangChain examples focus on visible tool inputs. This dives into the invisible arguments that actually drive LangChain tools at runtime.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/03/invisible-arguments-tools",
      "hashtags": "#LangChain #LLM #developers #AItools"
    },
    {
      "slug": "2026/03/orchestration-becomes-product",
      "file": "/data/automated-blog/2026/03/orchestration-becomes-product.json",
      "publishedAt": "2026-03-14T19:48:33+01:00",
      "title": "When Orchestration Becomes the Product",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-bb6bdadf-9941-4b22-b24f-bb0e9bdd62d7.png",
      "socialMediaPost": "When does coordination logic stop being just glue and start being what users actually feel? “When Orchestration Becomes the Product” digs into that shift.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/03/orchestration-becomes-product",
      "hashtags": "#orchestration #engineering #devtools"
    },
    {
      "slug": "2026/03/trainer-orchestrator",
      "file": "/data/automated-blog/2026/03/trainer-orchestrator.json",
      "publishedAt": "2026-03-19T16:29:07+01:00",
      "title": "When Your Trainer Becomes an Orchestrator",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-0c624ec4-ece5-48e2-bce2-650ed09bb1a0.png",
      "socialMediaPost": "When does a simple ML training loop stop being “just training” and start acting like an orchestrator for your whole system? This post digs into that shift.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/03/trainer-orchestrator",
      "hashtags": "#machinelearning #training #mlops #engineering"
    },
    {
      "slug": "2026/03/wrapper-stack-environments",
      "file": "/data/automated-blog/2026/03/wrapper-stack-environments.json",
      "publishedAt": "2026-03-24T13:08:27+01:00",
      "title": "The Wrapper Stack That Shapes RL Environments",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-983e16d5-24d8-4ca9-b278-9dedb7b6fb47.png",
      "socialMediaPost": "Most RL tutorials focus on agents, not what they’re actually interacting with. This dives into the wrapper stack that quietly shapes RL environments.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/03/wrapper-stack-environments",
      "hashtags": "#ReinforcementLearning #MachineLearning #AI"
    },
    {
      "slug": "2026/04/agent-loop-control-tower",
      "file": "/data/automated-blog/2026/04/agent-loop-control-tower.json",
      "publishedAt": "2026-04-11T15:52:22+02:00",
      "title": "When an Agent Loop Becomes a Control Tower",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-c81b0347-57df-4cc2-92e0-fa83ba9d50d2.png",
      "socialMediaPost": "When does an agent loop stop being simple iteration and start acting like a control tower for your AI system? This piece digs into that turning point ✈️",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/04/agent-loop-control-tower",
      "hashtags": "#AIagents #orchestration #softwaredesign"
    },
    {
      "slug": "2026/04/context-powers-mcp",
      "file": "/data/automated-blog/2026/04/context-powers-mcp.json",
      "publishedAt": "2026-04-25T13:11:52+02:00",
      "title": "The Context Object That Runs Your MCP Server",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-4cdad7d5-36e5-49a7-af8c-f744d53be91d.png",
      "socialMediaPost": "Running an MCP server and juggling logging, state, and requests across tools? See how a single context object can hold it all together without chaos.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/04/context-powers-mcp",
      "hashtags": "#MCP #server #context #backend"
    },
    {
      "slug": "2026/04/daemon-orchestration-scale",
      "file": "/data/automated-blog/2026/04/daemon-orchestration-scale.json",
      "publishedAt": "2026-04-08T04:07:41+02:00",
      "title": "Daemon Orchestration at Container Scale",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-395bcd92-a00c-4126-99f3-42274023c213.png",
      "socialMediaPost": "Most teams focus on container runtimes, not the control plane. Daemon Orchestration at Container Scale digs into how the daemon actually keeps fleets in line.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/04/daemon-orchestration-scale",
      "hashtags": "#containers #orchestration #devops #infrastructure"
    },
    {
      "slug": "2026/04/dynamic-angular-api",
      "file": "/data/automated-blog/2026/04/dynamic-angular-api.json",
      "publishedAt": "2026-04-22T18:33:34+02:00",
      "title": "The Tiny API That Powers Dynamic Angular",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-e69d77f4-8a22-44d6-aab5-81c462f4edac.png",
      "socialMediaPost": "Most people think Angular’s dynamic behavior comes from a huge surface area. This piece breaks down the tiny API that actually powers it.",
      "readingTime": "15m",
      "url": "https://zalt.me/blog/2026/04/dynamic-angular-api",
      "hashtags": "#Angular #webdev #TypeScript #frontend"
    },
    {
      "slug": "2026/04/engine-single-brain",
      "file": "/data/automated-blog/2026/04/engine-single-brain.json",
      "publishedAt": "2026-04-08T21:15:38+02:00",
      "title": "When Your Engine Has A Single Brain",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-263d661b-83eb-46aa-8448-d51c064ea45e.png",
      "socialMediaPost": "When your engine has a single brain, how do you keep it from collapsing under its own weight? This explores what happens when one place runs the whole show.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/04/engine-single-brain",
      "hashtags": "#software #architecture #engines #orchestration"
    },
    {
      "slug": "2026/04/ffmpeg-control",
      "file": "/data/automated-blog/2026/04/ffmpeg-control.json",
      "publishedAt": "2026-04-14T10:32:54+02:00",
      "title": "How FFmpeg Stays In Control",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-a2f7de5c-1ce0-4b19-ba40-8efcf2a07ea6.png",
      "socialMediaPost": "How does FFmpeg keep long, intensive jobs responsive instead of freezing up? “How FFmpeg Stays In Control” digs into the control layer behind the CLI.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/04/ffmpeg-control",
      "hashtags": "#FFmpeg #CLI #softwaredesign #programming"
    },
    {
      "slug": "2026/04/nginx-boot-engine",
      "file": "/data/automated-blog/2026/04/nginx-boot-engine.json",
      "publishedAt": "2026-04-17T05:13:50+02:00",
      "title": "How NGINX Boots a Zero‑Downtime Engine",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-4ac9c827-bbec-4ab2-b100-1b01b0bafc34.png",
      "socialMediaPost": "How does NGINX actually start up and keep serving traffic without interruptions? This breakdown of how it boots a zero‑downtime engine digs into that core idea.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/04/nginx-boot-engine",
      "hashtags": "#NGINX #webserver #infrastructure #devops"
    },
    {
      "slug": "2026/04/prometheus-tsdb-sanity",
      "file": "/data/automated-blog/2026/04/prometheus-tsdb-sanity.json",
      "publishedAt": "2026-04-03T07:28:30+02:00",
      "title": "How Prometheus Keeps Its TSDB Sane",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-b2776337-0bc6-4c06-88a7-d16456eddd0a.png",
      "socialMediaPost": "Working with time-series data at scale? “How Prometheus Keeps Its TSDB Sane” breaks down how Prometheus keeps its own storage manageable and safe.",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2026/04/prometheus-tsdb-sanity",
      "hashtags": "#Prometheus #TSDB #timeseries #observability"
    },
    {
      "slug": "2026/04/renderer-conducts-webgl",
      "file": "/data/automated-blog/2026/04/renderer-conducts-webgl.json",
      "publishedAt": "2026-04-28T07:52:34+02:00",
      "title": "The Renderer That Conducts WebGL",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-b69570a7-1570-4a48-b30e-ce940fa97bf0.png",
      "socialMediaPost": "The Renderer That Conducts WebGL rethinks how we see a rendering engine: not just drawing pixels, but coordinating the whole WebGL orchestra.",
      "readingTime": "40m",
      "url": "https://zalt.me/blog/2026/04/renderer-conducts-webgl",
      "hashtags": "#WebGL #graphics #rendering #javascript"
    },
    {
      "slug": "2026/04/routers-orchestrate-everything",
      "file": "/data/automated-blog/2026/04/routers-orchestrate-everything.json",
      "publishedAt": "2026-04-19T23:52:42+02:00",
      "title": "When Routers Orchestrate Everything",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-67c62fc0-44ec-4f38-ad0c-7cd1cbc30dcc.png",
      "socialMediaPost": "When routers orchestrate everything, they stop being simple traffic cops and start acting like conductors for the entire request lifecycle. Curious how that works? 🎼",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/04/routers-orchestrate-everything",
      "hashtags": "#webdev #backend #APIs #softwaredesign"
    },
    {
      "slug": "2026/05/babel-plugin-conveyor",
      "file": "/data/automated-blog/2026/05/babel-plugin-conveyor.json",
      "publishedAt": "2026-05-01T02:31:44+02:00",
      "title": "The Plugin Conveyor Belt Behind Babel",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-670a1207-915c-4cab-9ded-8046e98f8907.png",
      "socialMediaPost": "Ever wonder how Babel really works under the hood? The Plugin Conveyor Belt Behind Babel digs into the pipeline powering all those JavaScript transforms.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/05/babel-plugin-conveyor",
      "hashtags": "#Babel #JavaScript #plugins #buildtools"
    },
    {
      "slug": "2026/05/clickhouse-control-tower",
      "file": "/data/automated-blog/2026/05/clickhouse-control-tower.json",
      "publishedAt": "2026-05-14T23:53:42+02:00",
      "title": "The Control Tower Behind ClickHouse",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-69f2299a-3bbc-4851-9fcb-8bc556d187ce.png",
      "socialMediaPost": "Designing or running ClickHouse in production? “The Control Tower Behind ClickHouse” walks through how the server process actually coordinates everything.",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2026/05/clickhouse-control-tower",
      "hashtags": "#ClickHouse #databases #backend #infrastructure"
    },
    {
      "slug": "2026/05/event-loop-truth",
      "file": "/data/automated-blog/2026/05/event-loop-truth.json",
      "publishedAt": "2026-05-17T18:32:19+02:00",
      "title": "The Event Loop as a Single Source of Truth",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-0c3ce381-eacf-494f-83f3-29a721ac1e77.png",
      "socialMediaPost": "Most event-driven systems scatter state across queues, caches, and threads. “The Event Loop as a Single Source of Truth” argues for one clear authority instead.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/05/event-loop-truth",
      "hashtags": "#eventdriven #architecture #eventloop #concurrency"
    },
    {
      "slug": "2026/05/flutter-rebuild-engine",
      "file": "/data/automated-blog/2026/05/flutter-rebuild-engine.json",
      "publishedAt": "2026-05-06T15:53:20+02:00",
      "title": "The Hidden Engine Behind Flutter Rebuilds",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-4c2c7f74-7ea0-47d3-9ff9-b64a8a7e7d91.png",
      "socialMediaPost": "If your Flutter app feels janky, it might not be your widgets at all. Understanding the hidden engine behind Flutter rebuilds can change how you design UIs.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/05/flutter-rebuild-engine",
      "hashtags": "#Flutter #MobileDevelopment #UI"
    },
    {
      "slug": "2026/05/lazy-pipelines-fast-backends",
      "file": "/data/automated-blog/2026/05/lazy-pipelines-fast-backends.json",
      "publishedAt": "2026-05-29T07:12:36+02:00",
      "title": "Lazy Pipelines, Fast Backends",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-1e303512-a7bc-4dcc-ace2-851824d82398.png",
      "socialMediaPost": "Lazy Pipelines, Fast Backends digs into how to keep data pipelines easy to write while still hitting serious performance in the backend.",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2026/05/lazy-pipelines-fast-backends",
      "hashtags": "#datapipelines #backend #performance"
    },
    {
      "slug": "2026/05/llama-time-attention",
      "file": "/data/automated-blog/2026/05/llama-time-attention.json",
      "publishedAt": "2026-05-21T08:19:02+02:00",
      "title": "How Llama Treats Time in Attention",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-36bea129-c3a2-4589-b8d8-13eaf6f66e1e.png",
      "socialMediaPost": "Curious how Llama actually thinks about time inside attention? This breakdown of how it treats temporal information in its attention stack is worth a read.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/05/llama-time-attention",
      "hashtags": "#Llama #MachineLearning #AttentionMechanism #AIResearch"
    },
    {
      "slug": "2026/05/python-heart-safety-speed",
      "file": "/data/automated-blog/2026/05/python-heart-safety-speed.json",
      "publishedAt": "2026-05-09T10:31:50+02:00",
      "title": "How Python’s Heart Stays Safe at Full Speed",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-71c55dbe-c443-42db-b16e-e4a8fc3ab863.png",
      "socialMediaPost": "Pushing Python to its limits? “How Python’s Heart Stays Safe at Full Speed” digs into how the core runtime stays fast without sacrificing safety.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/05/python-heart-safety-speed",
      "hashtags": "#Python #CPython #programming #softwaredesign"
    },
    {
      "slug": "2026/05/registry-pattern-transformers",
      "file": "/data/automated-blog/2026/05/registry-pattern-transformers.json",
      "publishedAt": "2026-05-20T08:19:18+02:00",
      "title": "The Registry Pattern Behind Transformers’ Magic",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-708c4adb-87a7-45f8-a95a-3b9ac418d937.png",
      "socialMediaPost": "Transformers feel like magic, but they’re not. Curious how a simple registry pattern quietly powers their behavior behind the scenes?",
      "readingTime": "15m",
      "url": "https://zalt.me/blog/2026/05/registry-pattern-transformers",
      "hashtags": "#Transformers #MachineLearning #SoftwareDesign #Python"
    },
    {
      "slug": "2026/05/sparkcontext-control-tower",
      "file": "/data/automated-blog/2026/05/sparkcontext-control-tower.json",
      "publishedAt": "2026-05-12T05:13:35+02:00",
      "title": "SparkContext as a Control Tower",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-115982ea-bead-452f-9f10-bbd4ed65acae.png",
      "socialMediaPost": "Treating SparkContext as a control tower shifts how you think about Spark: not just as an API, but as the coordinator for your entire distributed engine.",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2026/05/sparkcontext-control-tower",
      "hashtags": "#ApacheSpark #SparkContext #distributed #systems"
    },
    {
      "slug": "2026/05/symbolic-shapes-guarantees",
      "file": "/data/automated-blog/2026/05/symbolic-shapes-guarantees.json",
      "publishedAt": "2026-05-22T07:11:17+02:00",
      "title": "Symbolic Shapes, Real‑World Guarantees",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-f9fc07b4-d841-445f-bd7f-0fe84100407d.png",
      "socialMediaPost": "How do you go from abstract models to guarantees you can rely on in production? “Symbolic Shapes, Real‑World Guarantees” digs into that bridge.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/05/symbolic-shapes-guarantees",
      "hashtags": "#softwaredesign #mlsystems #engineering"
    },
    {
      "slug": "2026/05/vertex-orchestrates-everything",
      "file": "/data/automated-blog/2026/05/vertex-orchestrates-everything.json",
      "publishedAt": "2026-05-03T21:11:26+02:00",
      "title": "The Vertex That Orchestrates Everything",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-17d4dbb3-2719-4735-b2ce-b2e9995456fc.png",
      "socialMediaPost": "Most systems scatter orchestration across many parts. What if you had a single vertex that quietly coordinates everything behind the scenes?",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2026/05/vertex-orchestrates-everything",
      "hashtags": "#softwaredesign #architecture #orchestration"
    },
    {
      "slug": "2026/06/autoregressive-loops-friendly",
      "file": "/data/automated-blog/2026/06/autoregressive-loops-friendly.json",
      "publishedAt": "2026-06-05T07:10:45+02:00",
      "title": "When Autoregressive Loops Stay Friendly",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-a0c9fe61-6e87-4d3a-a232-2fc03e5cc472.png",
      "socialMediaPost": "Working with autoregressive generation loops? \"When Autoregressive Loops Stay Friendly\" explores keeping them fast without making them painful to work on.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/06/autoregressive-loops-friendly",
      "hashtags": "#machinelearning #LLM #generativemodels"
    },
    {
      "slug": "2026/06/missing-files-mental-models",
      "file": "/data/automated-blog/2026/06/missing-files-mental-models.json",
      "publishedAt": "2026-06-12T07:09:33+02:00",
      "title": "When Missing Files Break Mental Models",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-1fb0290b-34d8-4358-98f5-1298664311d1.png",
      "socialMediaPost": "When Missing Files Break Mental Models digs into what happens when your code layout lies to you. If paths don’t match expectations, how far does the damage go?",
      "readingTime": "15m",
      "url": "https://zalt.me/blog/2026/06/missing-files-mental-models",
      "hashtags": "#softwareengineering #devexperience #codebase #mentalmodels"
    },
    {
      "slug": "2026/06/pydantic-facade-simplicity",
      "file": "/data/automated-blog/2026/06/pydantic-facade-simplicity.json",
      "publishedAt": "2026-06-01T10:36:51+02:00",
      "title": "The Facade That Makes Pydantic Feel Simple",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-acd84ac9-24b6-4000-a52f-e9281169e684.png",
      "socialMediaPost": "Struggle with how Pydantic stays so easy to use despite its depth? “The Facade That Makes Pydantic Feel Simple” breaks down the idea behind that simplicity.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/06/pydantic-facade-simplicity",
      "hashtags": "#Python #Pydantic #softwaredesign #APIdesign"
    },
    {
      "slug": "2026/06/transformations-engine",
      "file": "/data/automated-blog/2026/06/transformations-engine.json",
      "publishedAt": "2026-06-19T07:13:08+02:00",
      "title": "The Transformations Engine Behind JAX",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-3e3514d4-3348-4203-be1c-9312095680af.png",
      "socialMediaPost": "Curious how JAX actually wires gradients, JIT, and vectorization together? This piece breaks down the transformations engine behind JAX’s behavior.",
      "readingTime": "30m",
      "url": "https://zalt.me/blog/2026/06/transformations-engine",
      "hashtags": "#JAX #Python #MachineLearning #numericalcomputing"
    },
    {
      "slug": "2026/07/agent-orchestrator",
      "file": "/data/automated-blog/2026/07/agent-orchestrator.json",
      "publishedAt": "2026-07-24T07:13:40+02:00",
      "title": "When One Agent Orchestrates a Whole AI Stack",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-19f6cddf-190e-4a6c-81be-1b28e6f86401.png",
      "socialMediaPost": "When one agent orchestrates a whole AI stack, you stop wiring pieces by hand and start thinking in terms of a single control tower for your system 🧠",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/07/agent-orchestrator",
      "hashtags": "#AI #softwaredesign #agents #architecture"
    },
    {
      "slug": "2026/07/attention-efficiency",
      "file": "/data/automated-blog/2026/07/attention-efficiency.json",
      "publishedAt": "2026-07-07T21:26:41+02:00",
      "title": "Attention That Listens Efficiently",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-f812c659-1d07-4acb-ae2e-5a198aa1e34a.png",
      "socialMediaPost": "Most work on attention focuses on accuracy. “Attention That Listens Efficiently” asks a different question: how do you make attention fast enough to matter in practice?",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/07/attention-efficiency",
      "hashtags": "#transformers #deeplearning #attention #ML"
    },
    {
      "slug": "2026/07/graph-runtimes-sane",
      "file": "/data/automated-blog/2026/07/graph-runtimes-sane.json",
      "publishedAt": "2026-07-17T07:14:38+02:00",
      "title": "When Graph Runtimes Stay Sane",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-8a92a9d1-6696-48d7-9e19-816dee50fb6a.png",
      "socialMediaPost": "Building complex graph runtimes that don’t melt down over time is harder than it looks. “When Graph Runtimes Stay Sane” digs into what actually keeps them stable.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/07/graph-runtimes-sane",
      "hashtags": "#graphs #runtimes #distributedSystems #softwareArchitecture"
    },
    {
      "slug": "2026/07/one-engine-many-worlds",
      "file": "/data/automated-blog/2026/07/one-engine-many-worlds.json",
      "publishedAt": "2026-07-31T07:14:42+02:00",
      "title": "One Engine, Many Worlds",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-81e7ba8a-d5bd-4d06-a2c7-8c00f28efafc.png",
      "socialMediaPost": "Building systems where one engine safely powers many worlds? This piece explores how to centralize complex decisions without losing control.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/07/one-engine-many-worlds",
      "hashtags": "#softwarearchitecture #distributedtraining #systemsdesign"
    },
    {
      "slug": "2026/07/transformers-feels-fast",
      "file": "/data/automated-blog/2026/07/transformers-feels-fast.json",
      "publishedAt": "2026-07-10T07:12:41+02:00",
      "title": "How Transformers Feels Fast Without Cheating",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-d38db8a0-d67b-492e-af6f-41f487c4b368.png",
      "socialMediaPost": "Why do large Transformer-based libraries feel snappy even though they’re huge under the hood? This breaks down how they stay fast without cutting corners.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/07/transformers-feels-fast",
      "hashtags": "#transformers #MachineLearning #Python #Developers"
    },
    {
      "slug": "2026/08/keras-template-models",
      "file": "/data/automated-blog/2026/08/keras-template-models.json",
      "publishedAt": "2026-08-21T07:13:59+02:00",
      "title": "The Hidden Template Behind Keras Models",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-60b28d5e-a0ac-4eb8-ae13-130e2bf23899.png",
      "socialMediaPost": "Most people call model.fit() and move on. “The Hidden Template Behind Keras Models” digs into the design pattern that makes that simplicity possible.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/08/keras-template-models",
      "hashtags": "#Keras #TensorFlow #MachineLearning #SoftwareDesign"
    },
    {
      "slug": "2026/08/missing-core-module",
      "file": "/data/automated-blog/2026/08/missing-core-module.json",
      "publishedAt": "2026-08-07T07:09:52+02:00",
      "title": "When Your Core Module Goes Missing",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-3a90c3ed-2e63-42bd-a1db-d8c0e527d175.png",
      "socialMediaPost": "When your core module disappears, it’s rarely “just” a missing file. Here’s why a vanished hot-path module can signal deeper trouble in your system design.",
      "readingTime": "15m",
      "url": "https://zalt.me/blog/2026/08/missing-core-module",
      "hashtags": "#software #architecture #engineering"
    },
    {
      "slug": "2026/08/orchestrator-stable-diffusion",
      "file": "/data/automated-blog/2026/08/orchestrator-stable-diffusion.json",
      "publishedAt": "2026-08-14T07:12:07+02:00",
      "title": "The Orchestrator Behind Stable Diffusion",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-d55f844a-d04f-42d4-85ec-e53dca290d05.png",
      "socialMediaPost": "Who actually coordinates everything inside Stable Diffusion? This piece digs into the hidden orchestrator layer that turns prompts into images.",
      "readingTime": "25m",
      "url": "https://zalt.me/blog/2026/08/orchestrator-stable-diffusion",
      "hashtags": "#StableDiffusion #AI #MachineLearning #generativeart"
    },
    {
      "slug": "2026/08/reliable-llm-gateway",
      "file": "/data/automated-blog/2026/08/reliable-llm-gateway.json",
      "publishedAt": "2026-08-28T07:10:19+02:00",
      "title": "Designing A Reliable LLM Gateway",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-e625f645-78d8-444f-bd5e-451e92bc4f06.png",
      "socialMediaPost": "Designing a reliable LLM gateway isn’t just about wiring requests to a model—it’s about creating a single, stable entry point your backend can trust.",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/08/reliable-llm-gateway",
      "hashtags": "#LLM #backend #softwaredesign #aiinfra"
    },
    {
      "slug": "2026/09/kernel-must-say-no",
      "file": "/data/automated-blog/2026/09/kernel-must-say-no.json",
      "publishedAt": "2026-09-10T05:54:00+02:00",
      "title": "The Kernel That Must Say No",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-d58a5027-28f7-47cc-a92f-91484969fc09.png",
      "socialMediaPost": "A kernel cannot approve every request. “The Kernel That Must Say No” asks a practical engineering question: where should software draw the line between proceeding and refusing?",
      "readingTime": "15m",
      "url": "https://zalt.me/blog/2026/09/kernel-must-say-no",
      "hashtags": "#SoftwareEngineering #SystemDesign"
    },
    {
      "slug": "2026/09/llm-server-interface",
      "file": "/data/automated-blog/2026/09/llm-server-interface.json",
      "publishedAt": "2026-09-04T07:14:00+02:00",
      "title": "The Interface That Tames Your LLM Chaos",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-4a0c41d4-761c-4657-802c-8d3949f58af8.png",
      "socialMediaPost": "Wrangling prompts, models, and tooling into a mess of endpoints? “The Interface That Tames Your LLM Chaos” walks through one clean way to bring order 🧩",
      "readingTime": "20m",
      "url": "https://zalt.me/blog/2026/09/llm-server-interface",
      "hashtags": "#LLM #interfaces #softwaredesign #aiarchitecture"
    },
    {
      "slug": "2026/09/one-agent-one-run",
      "file": "/data/automated-blog/2026/09/one-agent-one-run.json",
      "publishedAt": "2026-09-11T07:12:17+02:00",
      "title": "Why One Agent Must Serve One Run",
      "type": "automated",
      "featured": false,
      "imageUrl": "https://zalt-me-blog.s3.us-west-1.amazonaws.com/assets/blog-images/zalt-0e20c99e-8fda-43ba-a522-8c3dd17161c6.png",
      "socialMediaPost": "Why must one agent serve one run? For engineers designing agent systems, this simple boundary offers a clearer way to think about ownership and responsibility.",
      "readingTime": "15m",
      "url": "https://zalt.me/blog/2026/09/one-agent-one-run",
      "hashtags": "#Engineering #SystemDesign #Concurrency"
    }
  ],
  "totalPosts": 63,
  "generatedAt": "2026-09-12T12:00:57.573Z"
}