GFM vs CommonMark vs Pandoc Markdown: Syntax Compared
Markdown looks like one language until the same file renders differently on GitHub, Hugo, Obsidian, or Pandoc. And the problem is not that Markdown is unreliable.
Rost Glukhov | Personal site and technical blog
Recent content on Rost Glukhov | Personal site and technical blog
Latest posts
Data Gravity: The Real Cost of API-First AI
Every API call feels like a simple transaction - until enough of them accumulate that your fine-tuning data, evaluation harnesses, and tool schemas are all shaped around one vendor, and switching stops being a routing change.
Claude Code Subagents: Setup, Config, and When to Use Them
Most Claude Code sessions get slow and cluttered for the same reason: every exploratory grep, every log dump, and every “let me check one more file” stays in the main conversation forever.
Ollama to vLLM: When to Migrate Your Local LLM Server
Ollama is one of the easiest ways to run a local language model, but convenience can conceal the moment when a local experiment becomes a shared inference service that needs better scheduling and observability.
Keeping Specs, Tests, And Code In Sync In AI Development
AI coding agents ship features fast, but specs, tests, and code quietly drift apart. This guide covers a traceability model, spec-to-test and spec-to-code mapping, and the CI checks that catch drift before a merge.
Dead Letter Queues: Handling Poison Messages in Distributed Systems
A dead-letter queue is the safety net that catches messages your consumers cannot process, so one broken payload does not block or silently drop everything behind it in the queue.
LLM Wiki Maintenance: Drift, Contradictions and Review
An LLM Wiki fails when old facts remain plausible, contradictions become polished, and generated summaries drift from their sources.
Syncthing File Sync for Self-Hosted Knowledge Systems
Syncthing keeps files synchronized across devices you control, making it one of the most practical tools for a self-hosted knowledge infrastructure that avoids cloud lock-in.
Circuit Breaker Pattern in Go: Stop Cascading Failures
A circuit breaker stops your Go service from hammering a failing dependency,
preventing cascading failures that consume goroutines, sockets, and memory until the entire system collapses.
Podman Quadlet vs Docker Compose for Linux Services
Docker Compose and Podman Quadlet solve overlapping problems but come from different design centers, and choosing between them depends on whether you think in application stacks or Linux services.
GPUs for AI in 2026: NVIDIA, AMD, Intel Compared
The AI hardware landscape has shifted significantly in 2026, with NVIDIA, AMD, and Intel all competing for developers who need GPUs capable of running local large language models and AI inference workloads.
Hermes Agent: Headless Server + Remote Desktop Setup
Running Hermes Agent on a headless server while connecting from a desktop client on another machine requires two server processes and a single client connection.
GitHub Spec Kit vs Kiro vs Claude Code SDD Workflows
Developers comparing Spec-Driven Development setups in 2026 are usually not asking which model is smartest. They are asking which workflow will keep an AI agent aligned without burying them in ceremony.
Spec-Driven Development Workflow From Requirements to Code
Spec-Driven Development works when the specification is a workflow, not a document you file away after kickoff. The point is not to produce a large product requirements document.
A2A and MCP Agent Security: Identity, Delegation, and Audit Trails
Prompt injection gets most of the security attention in LLM systems, and it deserves attention, but it is not the whole problem once agents start calling tools and delegating work to other agents.
A2A Streaming and Async Tasks for Long-Running Agent Workflows
Most AI agent demos still behave like chat completions with extra steps: you send a prompt, wait a few seconds, and get an answer back in one response.
Run Docker Compose as a Linux Service with systemd
Docker Compose on a Linux server should start on boot, stop cleanly on shutdown, and survive reboots without manual intervention.
Install Docker on Ubuntu: APT, Snap, Rootless — Complete Guide 2026
Installing Docker on Ubuntu should be simple, but in practice several Docker-shaped options compete for the same command name, each with different packaging, upgrade behavior, and security implications.
Ubuntu APT Troubleshooting: Fix Broken Packages, Holds, and GPG Errors
APT failures are common on long-lived Ubuntu machines, and they usually appear after a release upgrade, a third-party repository change, a removed PPA, a manually installed .deb , or an interrupted package installation.
Speculative Decoding: 20-50% Faster LLM Inference
A 70B model generates one token per forward pass, and each pass reloads weights from VRAM, computes attention across the context, and synchronizes memory. Between tokens, the GPU sits idle while it waits for sequential dependencies to resolve.
Multi-Agent Orchestration Patterns: A Practical Guide
Single-agent AI systems peaked in 2025 — you gave one LLM a prompt, some tools, and a goal, and it did reasonably well on bounded tasks.
Transactional Outbox Pattern in Go with PostgreSQL
Two writes that should succeed together will eventually fail separately.
Your order service saves the order to the database, then publishes an order.created event to a message broker.
Go context.Context Done Right: Cancellation, Timeouts, and Values
Go’s context.Context is simple enough to use badly — and that is the problem.
What Is Spec-Driven Development? The Spec as Source of Truth
Spec-Driven Development is one of those ideas that software engineers have reached for before
and then set aside when the effort stopped paying.
Spec-Driven Development vs Vibe Coding: Waterfall?
Spec-Driven Development entered 2026 as the serious developer’s answer to vibe coding drift.
Decision Records for AI-Driven Software Development
Decision records are the missing memory layer in AI-assisted software development. They capture not just what was built, but why — and that distinction becomes critical when AI tools are writing your code.
Go Error Handling Architecture: Boundaries and Patterns
Go error handling is easy to complain about.
Every Go developer has written this code hundreds of times:
Testing Concurrent Go Code with synctest
Testing concurrent Go code has always required a bit of discipline.
Goroutines are cheap, channels are simple, and context cancellation is idiomatic — background workers and timers are everywhere in real Go services.
Google A2A Protocol in 2026: Adoption, Hype, and Reality
Google’s Agent2Agent protocol, usually shortened to A2A, had a strange first year.
Polling Agents in AI Assistants: 11 Implementation Patterns
Polling agents are one of the least glamorous parts of AI assistant architecture, but they are also one of the most useful.
A2A vs MCP: Do AI Agents Really Need Both Protocols?
AI agent architecture is starting to split into two layers.
What Is the A2A Protocol? Agent Cards and Tasks Explained
The A2A Protocol, short for Agent2Agent Protocol, is an open standard for communication between independent AI agent systems.
Implementing CQRS in Go: A Practical Guide to Scalable Architecture
CQRS is one of those patterns that gets oversold, overcomplicated, and occasionally misdiagnosed as a cure for plain old CRUD boredom.
Mermaid Diagrams Quickstart and Cheatsheet for Developers
Mermaid is a text-based diagramming tool for people who would rather write diagrams than drag boxes around a canvas.
Digital Gardens: Grow Knowledge Instead of Just Publishing It
The dominant model for publishing knowledge online has not changed much since the early 2000s: write something, polish it, publish it, move on.
Evergreen Notes: Write Notes That Compound Over Time
Most engineering notes are written once and forgotten. You capture something in a debugging session, paste it somewhere, and find it two years later with no context for why it mattered.
PARA Method for Engineers: Organize Knowledge by Action
Organizing notes by topic sounds logical until you have notes on PostgreSQL in five different folders and cannot find the one that matters for today’s problem.
Cost Optimization for LLM Systems: Where the Money Actually Goes
LLM costs scale linearly with usage. A system processing 10,000 requests a day at $0.01 per request costs $100 daily — $365 a year. At enterprise scale, that’s over $10,000.
LLM Guardrails in Practice: What Actually Works
LLMs are unpredictable. They hallucinate, leak data, generate harmful content, or refuse legitimate requests. Guardrails constrain model behavior without sacrificing capability.
Model Routing: Stop Using One Model for Everything
Running a 70B parameter model to summarize a 200-word email is wasteful. Running a 3B model to review production code is reckless. Most systems live somewhere in between — and that’s where model routing comes in.
Multi-Model System Design: When One Model Isn't Enough
Single-model systems are simple. Multi-model systems are powerful. The challenge isn’t choosing models — it’s designing the architecture that orchestrates them.
Memory Systems in AI Assistants
Memory turns assistants from reactive to persistent, but it is also where many systems quietly rot. Surveys argue the short-term versus long-term split is no longer enough for modern agent memory; OpenAI and LangGraph SDKs point to a simpler stack — working memory, durable state, and retrieval.
AI Assistant Architecture: LLM, Memory, Tools, Routing, Observability
A production AI assistant is not “an LLM with a prompt”. It is a system that accepts intent, keeps state, decides when to retrieve or act, and exposes enough runtime detail to debug failures.
AI for Knowledge Management: Real Workflows That Hold Up
AI is not replacing knowledge management; it is changing the shape of it for both individuals and teams.
Zettelkasten for Developers: A Practical Method That Works
Developers do not usually suffer from a lack of information. We suffer from too much of it.
OpenClaw vs Hermes Agent: Stars, Downloads & Usage 2026
Open-source AI agent frameworks are exploding in popularity on GitHub.
Two projects at the core of the self-hosted AI systems ecosystem — OpenClaw and Hermes Agent — have pulled so far ahead that the rest of the field is fighting for a distant third place.
Qwen 3.6 27B and 35B MTP vs Standard on 16GB GPU
I tested Speculative decoding (Multi-Token Prediction, MTP) performance in Qwen 3.6 27B and 35B on an RTX 4080 with 16 GB VRAM.
Unload All llama.cpp Router Models Without Restarting
llama.cpp router mode is one of the most useful changes to llama-server in years. It finally gives local LLM operators something close to the model management experience people expect from Ollama, while keeping the raw performance and low-level control that make llama.cpp worth using in the first place.
Retrieval vs Representation in Knowledge Systems
Most modern knowledge systems optimize retrieval, and that is understandable.
Search is visible, easy to demo, and feels magical when it works. Type a question, get an answer.
LLM Wiki - Compiled Knowledge That RAG Cannot Replace
The premise is simple: compiled knowledge is more reusable than retrieved fragments.
RAG became the default answer to a straightforward question - how do I give an LLM access to external knowledge?