Articles

The full archive: long-form deep dives on software engineering, cloud and distributed systems, databases, and getting AI agents to do dependable work.

Before You Trust an LLM Judge, Measure Its Noise Floor — An evaluation score moved from 0.81 to 0.84 and the change shipped. Measuring what your judge produces on unchanged input, before you trust the difference.
What an Agent Trace Reveals, and What It Cannot Prove — Tracing is the first thing teams instrument and the last thing they reason about. What a trace genuinely establishes, and the questions it cannot answer.
Evaluating AI Agents on Databricks — When the correct output is a set rather than a value, you cannot assert it. Code scorers, LLM judges, and where each one belongs in an evaluation.
Calling Databricks from ASP.NET Core Without Building a Fragile Integration — A cold warehouse, a double-clicked button, and a deploy mid-request. The state machine and idempotency work that keeps an ASP.NET Core integration from going fragile.
A session should survive a node change — Long-lived agents, auth redirects, and cross-region failover all punish the same design: session truth trapped in one worker. Treat sessions as portable references to durable state, and keep sticky sessions on a removal plan.
GitHub Actions OIDC should trust workflows, not repositories — GitHub lets any job with `id-token: write` choose its OIDC audience at runtime. If your cloud trust policy keys on repo identity alone, separate workflows share one blast radius.
Seven Signals That a Databricks Repository Is Still a Prototype — Seven cheap checks that tell you whether a repository was promoted to production by decision or by usage, and which failure will arrive first.
The SQLite CVE mess shows where your vulnerability automation needs a gate — A bad advisory turns expensive once scanners, ticket bots, and coding agents treat it as work. The SQLite episode points to a simple boundary: verify provenance and evidence before severity fans out into your pipeline.
Treating Databricks Projects as Software Products — Ask a data team what they deploy and the answer is a notebook. What changes when a Databricks project gets a versioned artefact, a test gate, and its own identity.
The SOC 2 controls you already run, and the five gaps that stop them counting — Most of what a SOC 2 report tests, your team already does. Five gaps separate the practice from the control an auditor can test, and closing four of them is writing rather than engineering.
Coding agents make senior engineers more valuable, if the rulebook leaves their head — Coding agents make implementation cheap, which raises the return on local judgement. Teams capture that upside when they turn subsystem invariants, failure modes, and review heuristics into small playbooks that both agents and reviewers use.
Open weights are now part of your AI disaster-recovery plan — The late-July fight over Chinese open-weight models exposed a new failure mode for production teams: losing access to a model family for reasons outside your roadmap. Treat open-weight failover like DR, classify workloads now, and rehearse the switch before policy or licensing changes make the call for you.
Open-weight access now belongs in your AI supply chain — Anthropic’s July 2026 open-weights statement and fresh U.S. policy pressure around Chinese open models change what portability has to cover. For production agents, fallback planning now needs policy-aware routing, not a model dropdown.
The Sequence Column Is a Business Decision — SEQUENCE BY decides which version of a record wins, and that is a question about the business. What each of the usual timestamp candidates actually asserts.
Designing an Idempotent CDC Pipeline with Lakeflow — CDC pipelines rarely throw. They produce a target table that is quietly wrong. What AUTO CDC handles for you, and the four decisions it still leaves open.
The SOC 2 deadline that matters is the start of your observation window — A SOC 2 Type 2 report grades a period of time, and you cannot go back and collect the evidence afterwards. The controls worth wiring into your pipeline before the observation window opens.
PGSimCity is the Postgres refresher you need before parallel agents melt your pool — Agent-heavy backends usually do not break PostgreSQL in new ways. They make old failure modes arrive faster, and PGSimCity is a good mental model for deciding what to cap and measure first in a Node service on Azure.
The Reliability Contract of a Databricks Pipeline — A pipeline becomes production when you can answer what it does when the same row arrives twice. Twelve questions, and most of them are business decisions.
The bowling alley lesson isn’t “one hacker did it” — ugly verticals just got cheap enough for small teams — A $105k bowling center facing an $80k–$120k control-system replacement is not a curiosity. It’s a case study in how six-figure vertical software is collapsing into cheap edge hardware, a narrow event backend, and a boring operator UI.
Dependabot's cooldown is the policy your Node repo needed once agents sped up dependency churn — GitHub's new three-day delay matters less as a Dependabot feature than as a supply-chain lesson. In Node and TypeScript repos, dependency freshness now needs a policy: wait on public packages, move faster only by written exception.
Take-home projects are untrusted code, so give them a sandbox — A take-home repo, OSS sample, or blob of agent-generated code feels temporary, which is exactly why engineers get sloppy with it. The machine does not care: startup automation and ambient credentials turn casual evaluation into a trust boundary.
Your eval harness needs its own threat model — A private eval harness is valuable because it mirrors your real system boundaries. That also means it needs the same kind of security thinking as CI: isolation, provenance, and hard failure on policy violations.
Model portability is now a governance feature for AI agents — A fast-moving model market changes the job of agent architecture. Portability now belongs in governance: prompts, tool contracts, evals, and fallback paths should survive a model swap.
Your real moat after GPT-5.6 and Kimi K3 is a private eval harness — Public benchmarks can narrow the field, but they decay fast and they do not test your permissions, tools, or network policy. The durable advantage is a private eval harness that can replay real tasks and gate rollout by task class.
Trust Boundaries for AI Agents: Securing Automated Workflows — Prompt injection can't be prompted away. This is a practical guide to containing AI agents in automated workflows by drawing trust boundaries: mapping the "lethal trifecta" to your own wiring, scoping tools instead of tokens, and putting deterministic gates on the steps that actually cause conseque
Arm-Based Cloud Compute for Agentic AI: A Look at Azure Cobalt 200 — Azure Cobalt 200 is an Arm CPU, not an accelerator, so why is it pitched for agentic AI? Because the expensive part of an agent is increasingly the orchestration plane, not the model call. A look at the 132-core Neoverse V3 chip and where it actually fits.
Build Your Own Code Agent: Tool Calling, Memory, and MCP from Scratch — Strip away the framework and a code agent is a while loop over tool calls. Here's how the calling contract, the message-array memory, and MCP fit together, and where each one breaks.
Ensemble LLMs: How Multi-Model Fusion Picks the Best Answer — Multi-model fusion isn't majority voting. It's a judge that sorts panel answers into consensus, contradictions, unique insights, and blind spots. A look at OpenRouter's Fusion tool, its benchmark numbers, the API shape, and when the fan-out tax actually pays off.
Postgres for the AI Era: Inside Azure HorizonDB — Azure HorizonDB rebuilds Postgres on a database-as-logs engine and pushes vector search and model inference inside the transaction boundary. A look at the architecture, DiskANN filtered search, and what adopting it actually costs.
Parallel Agent Orchestration: Building Multi-Agent Pipelines — Why the fan-out is the easy part of a multi-agent pipeline, and why the real engineering lives in task decomposition, the token bill, and the fan-in that stitches parallel workers back together.
How Reinforcement-Learning Environments Train Better Coding Models — The scarce resource for frontier coding models is no longer data. It's sandboxed environments where a model attempts real engineering work and gets scored by a grader it can't fool. A look at how those environments are built, how rewards are designed, and why the hard part is keeping high reward ho
When AI Agents Drift: Preference Shift Under Load — AI agents don't get dumber over long sessions. They drift off the instructions you set early. Here's the mechanism behind preference shift under load, why drift converges instead of exploding, and the cheap re-anchoring fixes that beat a model upgrade.
Supervising Long-Running AI Agents: Outcome Grading and Webhooks — When an agent runs for 40 minutes instead of 40 seconds, polling and eyeballing the output stop scaling. Two primitives replace the babysitting: webhooks tell you when a session changes state, and a separate rubric-based grader tells you whether the work is actually correct: composing into a superv
Cutting LLM Costs by Nearly Half: A Practical Pre-Scale Playbook — Before you downgrade the model, stack four boring, quality-neutral levers: prompt caching, batch APIs, difficulty routing, and output discipline, and watch a $10K bill fall by roughly half.
Hardening Your Code-Signing Pipeline Against Supply-Chain Attacks — A code signature proves who vouched for a set of bytes, not that those bytes are the ones your team wrote. Using the SolarWinds compromise as the anchor, this walks through why the signer is the last link attackers touch and how to harden the pipeline that feeds it: keyless signing with Sigstore, bu
Scheduling Unattended Coding Workflows with Agent Routines — Putting a coding agent on a cron is the trivial part. The real work is designing a memoryless, unattended run that ends in a reviewable artifact: a PR or a filed task: instead of an irreversible action. A field guide to routines, output contracts, and the guardrails that make "runs while you sleep
Recurrent-Depth Transformers Explained: Looped Reasoning and MoE Routing — Recurrent-depth transformers spend inference compute by looping a shared block in latent space instead of emitting reasoning tokens, and the adaptive exit that decides how many loops each token gets is really just MoE routing over depth.
Anatomy of a Supply-Chain Breach: When a Connector Leaks Your Secrets — A hop-by-hop breakdown of the April 2026 Vercel breach: how a compromised AI connector became a pivot into plaintext customer secrets, why no cryptography had to break, and how write-only "sensitive" environment variables would have ended the same intrusion in ciphertext.
From AI Editor to Agent Orchestrator: Managing Parallel Coding Agents — Cursor 3 made the agent queue, not the editor, the main surface. Running up to eight coding agents in parallel turns generation into a solved problem and integration into the real bottleneck. Here's the orchestration discipline that keeps it from collapsing.
Model-Agnostic Coding Agents: One CLI Across Many LLMs — Terminal coding agents like Aider, OpenCode, and Cline decouple the agent harness from the model, so switching LLM providers becomes one line of config instead of a whole new tool. Here's how the abstraction works and why you'd use it.
Giving AI Agents Persistent Memory: Lessons from LongMemEval — Naive "embed the chat log and retrieve top-k" memory fails the exact queries users care about: updated facts, temporal references, and knowing when to abstain. LongMemEval quantifies the drop and points to four concrete design levers: round-level storage, fact-augmented indexing, time-aware retriev
Automating Security Reviews in Your PR Pipeline — A practical walkthrough of putting Claude's automated security review at the pull-request gate: the /security-review slash command, the ~12-line GitHub Action, and why aggressive false-positive filtering is what keeps the gate from becoming wallpaper.
How a Source Map Can Leak Your Entire Source Code — A shipped .map file isn't a debugging convenience that de-minifies your JavaScript. Its sourcesContent field embeds your original source verbatim, comments and all. Here's the anatomy of the leak, how attackers reconstruct a whole codebase in one command, and the build-and-server config that keeps
Beyond Bypass Permissions: Risk-Aware Autonomy for Coding Agents — The choice for a coding agent was never "confirm everything" versus "skip all checks." A look at how risk-aware auto mode inserts a second classifier model between the agent and your machine, why that is judgment rather than isolation, and how to stack a sandbox, auto mode, and deny rules into auton
A Stack Overflow for AI Agents: Shared Knowledge Bases That Cut Wasted Work — AI agents solve the same problems in isolation and forget them the moment a session ends. Here's why the hard part of a shared knowledge base isn't storage or search but trust, freshness, and recording failures, and what to build first.
Event-Driven AI Agents: Pushing Real-Time Events into a Session — Modeling an agent as a long-running session you push events into: not a function you call and await. Is what lets you interrupt, redirect, and steer it mid-run. A concrete look at the event model behind the Claude Agent SDK and Managed Agents.
Giving Coding Agents Database Awareness with a Cosmos DB MCP Plugin — Coding agents write queries against schemas they've never seen. The Azure Cosmos DB MCP Toolkit closes that gap with seven read-only tools, Entra ID auth, and a deliberate no-writes design. Here's how it works and why read-only is the right default.
Harness Design: Structuring AI Agents for Long-Running Builds — Finishing multi-hour agent builds is a harness-design problem, not a model-intelligence one. A look at the concrete patterns: the initializer/coding split, feature-list checklists, planner/generator/evaluator roles, and artifact handoffs. That keep project state legible across context resets.
How AI Finds Vulnerabilities Traditional Scanners Miss — Pattern-matching scanners can only find bug classes someone already wrote a rule for. Here's why reasoning over code semantics surfaces the logic and access-control flaws that survive decades of human review and fuzzing, and how to wire a semantic review into your pipeline.
From Writing Code to Directing It: How the Developer Role Is Shifting — AI agents doubled how much code teams produce but left delivery flat, because the bottleneck moved from writing to reviewing. Here's why directing code: precise specs, executable verification, hard-won judgment. Is the job now, backed by 2025-2026 data from Faros AI, METR, and Anthropic.
Making the Most of Million-Token Context Windows — A million-token window is a curation problem, not a capacity problem: why filling it makes outputs worse, and the placement, quote-grounding, and just-in-time retrieval techniques that actually help.
From Code to Canvas: Turning Production UI into Editable Figma Designs — Importing a shipped screen back into Figma as editable layers is now a seconds-long operation, but it is not the same thing as keeping design and code in sync. Here is how the conversion actually works, and when to reach for Code Connect instead.
Writing Effective Specs for AI Agents — A thin prompt turns every gap in your description into a decision the agent makes silently. Here is how to write specs that close those gaps: using EARS-style testable requirements, a spec-plan-tasks structure, and knowing when the ceremony isn't worth it.
Inside Agentic Coding Models: Long-Context Self-Summarization and RL — How Cursor's Composer model turns context compression into a reinforcement-learning action, so a coding agent can run across hundreds of turns without its accuracy degrading past the context window.
Breaking the Stack: How Adversarial Attacks Bypass Layered LLM Safeguards — Layering an input classifier, an aligned model, and an output classifier drops most jailbreaks to near zero: until you attack the layers one at a time. A look at the STACK staged attack, why the "defense in depth" intuition borrowed from network security breaks down for LLM safeguard pipelines, and
Building Cosmos DB Infrastructure with an AI Agent Kit — An AI coding agent will happily write Cosmos DB Terraform that plans cleanly and quietly bakes in the wrong defaults. Microsoft's open-source Cosmos DB Agent Kit is a knowledge layer: 120+ battle-tested rules. That flips those defaults toward production. Here's what it changes in a real infra revi
Coordinating Parallel AI Agents on Long-Running Engineering Tasks — Coordinating a fleet of AI agents is a state-management problem, not an intelligence one: the shared artifacts they read and write are what hold parallel and long-running work together, drawn from Anthropic's multi-agent research and long-running agent engineering.
Why Agent Evaluations Matter: What a Vending-Machine Sim Reveals — A frontier model can ace hard benchmarks and still spiral into calling the FBI over a $2 daily fee. Andon Labs' Vending-Bench shows why long-horizon coherence, and the variance across runs. Is the eval that actually matters for autonomous agents.
Copilot in SSMS: AI-Assisted T-SQL in SQL Server Management Studio — GitHub Copilot in SSMS 22 isn't fancier autocomplete. It runs inside your session, under your login, aware of your connection, schema, and execution plans. A practical look at the context model, slash commands, agent mode, and where the permission boundary makes AI-assisted T-SQL actually safe.
Building a Better AI Code Reviewer: What Makes Review Trustworthy — Trust in an AI code reviewer collapses as a step function, not a slow slide, so the real engineering problem isn't finding more bugs, it's protecting the reader's attention. Here's what that takes.
Parallel AI Coding: Subagents and Agent Skills in a Modern Editor — Subagents and Agent Skills solve the same context-budget problem from opposite directions. Here's how isolation and progressive disclosure combine to let you run several AI coding tasks at once without any of them drowning the others.
MCP Apps Explained: Interactive Tool UIs Inside the Chat — MCP Apps is the first official Model Context Protocol extension: it lets a server ship an interactive UI alongside a tool, rendered in a sandboxed iframe right in the conversation. Here is how the ui:// resource model, the _meta.ui link, and the JSON-RPC-over-postMessage contract actually fit togeth
When Your AI Assistant Gets Hacked: Prompt Injection and Exposed Gateways — A zero-click email that leaked corporate data through Microsoft 365 Copilot, plus thousands of unauthenticated MCP servers on the open internet, show why AI security is set by the least-privileged tool your agent can touch: not by how well the model resists a jailbreak.
One Language for AI Commerce: Inside the Universal Commerce Protocol — The Universal Commerce Protocol, launched January 2026, collapses the N×M integration tax between AI shopping agents and merchants. A technical look at why its real innovation is capability negotiation: content negotiation for commerce: not the checkout itself.
An Agentic Coding Workflow That Scales: Hooks, Sub-Agents, and Feedback Loops — Reliable agentic coding isn't a smarter model. It's the structure around it. A practical breakdown of the three primitives that make a coding-agent workflow scale: deterministic hooks as guardrails, sub-agents for context isolation, and verify-and-iterate feedback loops.
Context on Demand: How Dynamic Context Discovery Cuts Agent Token Use — Agent frameworks load every tool definition upfront, burning tens of thousands of tokens before real work starts. Deferred tool loading and code-execution MCP let agents fetch context on demand instead: cutting token use by up to 98.7% and, counterintuitively, raising accuracy.
The Free Prompt Hack: Why Repeating Your Prompt Helps Non-Reasoning LLMs — A recent Google Research paper shows that pasting your prompt in twice: literally <QUERY><QUERY>: boosts direct-answer accuracy on frontier LLMs, in one case by 76 points, for zero extra output tokens. Here's why causal masking makes it work, where it helps, and the one setting that ca
Can an AI Agent Run a Business? Lessons from an Autonomy Experiment — Anthropic and Andon Labs let an AI agent run a real office shop for a month. It lost money, hallucinated a coworker, and gave the store away, and the fixes that turned it profitable were scaffolding, not a smarter model. Here's what that teaches anyone shipping agents.
The 2025 LLM Year in Review: RLVR, Test-Time Compute, and Jagged Intelligence — Why 2025's biggest LLM gains and its strangest failures came out of the same pipeline, and how to build systems that treat model capability as spiky rather than smooth.
Learning Machine Learning in a Spreadsheet — A spreadsheet is a computational graph you can touch, which makes it the best place to actually understand gradient descent, neural nets, and even a GPT-2 forward pass before a framework hides them from you.
AI in the Inspector: Debugging Faster with Chrome DevTools Assistance — Chrome DevTools now ships Gemini-powered AI assistance across the Elements, Network, Sources, and Performance panels. The real win isn't the chat box. It's that the model reads the exact element, request, or flame graph you've selected. Here's how the workflow actually changes, and what to check be
Dialing Reasoning Depth: A Developer's Guide to Gemini 3's thinking_level — Gemini 3 swaps the fiddly thinking_budget token count for thinking_level: minimal, low, medium, high. A practical guide to the values, per-model defaults, the 400 that trips migrations, and how to pick a level per route.
AGENTS.md Explained: A README for Your AI Coding Agents — AGENTS.md is a plain-Markdown file that tells AI coding agents how your project actually builds, tests, and ships, so they stop guessing. Here's what it is, how the nearest-file-wins mechanic scales to monorepos, and why its December 2025 move to the Linux Foundation made it a real standard.
Building MCP Servers by Dragging Blocks: Visual MCP Explained — Visual, block-based MCP builders work because an MCP tool is a tiny declarative contract. Here's what the canvas automates, the two things it can't, and when to drag blocks versus hand-write the server.
Guarding Agentic Browsers: How Chrome Fights AI Prompt Injection — Chrome's new security architecture for Gemini's agentic browsing doesn't try to make the model injection-proof. It assumes the model will be fooled and constrains the data flows around it. A breakdown of the User Alignment Critic, Agent Origin Sets, and what transfers to any agent you build.
Does AI Really Make You 80% Faster? Reading a Productivity Study — Anthropic measured a median 84% time saving per task across 100,000 Claude conversations. Here's why that number doesn't mean your team ships 84% faster, and how Amdahl's Law, unmeasured refinement work, and a damning METR trial explain the gap between task-level speedups and real productivity.
Editing SQL Data with AI: Copilot in the VS Code MSSQL Extension — The MSSQL extension for VS Code v1.37 shipped two ways to change table data without hand-writing DML: the Edit Data grid and Copilot agent mode. They look alike but have very different trust models. Here's how to use each safely.
Your Pocket DevOps: Managing Apps with the Aspire MCP Server — The Aspire MCP server hands your AI coding agent a live view of a running distributed app: resources, logs, traces, and the commands to act on them. Here's what it exposes, how to wire it up with one CLI command, and why running over STDIO changes the security math.
A 7B Model That Drives Your Computer: Efficient Agentic Models Explained — Microsoft's Fara-7B runs a computer-use agent on-device with just 7 billion parameters. The real lesson isn't small-model bragging rights. It's that verified trajectory data, not model scale, is what makes agentic computer use work.
Turn Your Azure APIs into MCP Servers with API Management — Azure API Management can project the REST APIs you already govern as Model Context Protocol tools: behind the same gateway, with the same auth, rate limits, and telemetry. Here's how it works, the streaming gotcha that will cost you an afternoon, and where the feature's edges currently are.
Semantic Code Search: How Embeddings Speed Up AI Coding Assistants — Grep finds strings; AI agents need to find meaning. A look at how Cursor trained a custom embedding model on agent traces, the measured accuracy gains, and the vector-database plumbing that makes semantic code search work at scale.
Building Generative AI Apps in .NET: A Hands-On Course Breakdown — An opinionated walkthrough of Microsoft's five-lesson Generative AI for Beginners .NET course, and why its real payload is the IChatClient abstraction that turns AI model providers into ordinary swappable .NET dependencies.
A First Look at Agent-First AI IDEs — Google's Antigravity reframes the IDE around a fleet of autonomous agents instead of the text buffer. A look at what "agent-first" actually changes: the demoted editor, plans and browser recordings as reviewable artifacts, and why verification bandwidth, not code generation, becomes the real bottle
Meet Seer: How an AI Debugger Diagnoses Production Errors — A technical look at Sentry's Seer: how an AI debugging agent walks backward through stack traces, spans, logs, and profiles to find the line that actually caused a production error: plus its 94.5% root-cause accuracy, three-step autofix pipeline, and where to keep a human in the loop.
Anatomy of the First Reported AI-Orchestrated Cyber Espionage Campaign — An engineer's reading of the GTG-1002 campaign Anthropic disrupted in September 2025: not a new weapon, but a textbook orchestrator-worker agent pipeline: MCP tool servers, task decomposition, persistent state: pointed at intrusion, with a human in the loop only four to six times per target.
An Autonomous Security Researcher for Finding Bugs — OpenAI's Aardvark is billed as a GPT-5 agent that finds and fixes security bugs, but the design decision that actually matters is that it reproduces every vulnerability in a sandbox before reporting it: the same reproduce-first discipline that makes a test worth trusting.
Why Small Language Models Are the Future of Local Setups — Running models on your own hardware used to mean trading capability for privacy. Sub-10B models and new step-wise training methods are erasing that tradeoff. Here's why the local setup is becoming the default rather than the fallback.
Cutting Token Bills: Converting JSON to TOON for Leaner LLM Prompts — JSON re-declares its structure on every row of an array, and you pay per token for all of it. TOON keeps the same data model but drops the repeated syntax: cutting 30–60% of tokens on uniform data while holding or improving retrieval accuracy. Here's what it is, the benchmark numbers, how to try it
Cursor 2.0: Multi-Agent Coding and What Actually Changed — Cursor 2.0 ships Composer, an in-house model tuned for sub-30-second agent turns, alongside an interface rebuilt around agents instead of files. Here's what genuinely changed for your workflow, and why the bottleneck moved from writing code to deciding which output to trust.
Plan Before You Prompt: Copilot's New Planning Mode in Visual Studio — Visual Studio 2022's new Planning preview makes Copilot write a plan before it acts, and turns that plan into a real, editable file on disk. Here's what it does, whether the SWE-bench numbers hold up, and the preview rough edges to know before you rely on it.
AI That Patches Your Code: Inside an Autonomous Vulnerability Agent — In late 2025, three autonomous security agents shipped within weeks of each other: CodeMender, Aardvark, and the DARPA AIxCC finalists, and converged on the same architecture. A mechanism-level look at the find-prove-patch loop that separates these agents from a linter, why the validation step is
Context Rot: The Research on Why LLM Quality Degrades — Frontier models don't use their context windows uniformly. New research shows quality decays as inputs grow longer, and a second, deeper "brain rot" gets baked in during training. Here's what each one is and how to build around them.
Fine-Tuning for the Edge: A Gemma 3 270M On-Device Walkthrough — A hands-on walkthrough of specializing Google's 270M-parameter Gemma 3 with QLoRA on a free Colab T4, quantizing it to under 300MB, and shipping it to run entirely in a browser tab with no inference server.
Claude Skills: Packaging Instructions and Scripts Your AI Loads on Demand — Claude Skills package expertise as a folder: a SKILL.md file plus reference docs and scripts. That the model pages into context only when a task needs it. Here's how progressive disclosure works, why bundled scripts matter, and how to write one well.
Apps Inside ChatGPT: Building on the MCP App Platform — OpenAI's Apps SDK is the Model Context Protocol with a UI layer and a distribution channel attached. Here's what your MCP server actually exposes, the three-way data split that trips developers up, and what you give up when ChatGPT owns app discovery.
Big Models, Local Tools: Ollama's Cloud Models Explained — Ollama's cloud models let you run 480B-class models behind the same local interface your tooling already speaks. Here's how the -cloud suffix, the localhost proxy, and the two API paths actually work, plus what you trade for lifting the VRAM ceiling.
Codex Goes Agentic: Running a Coding Model Autonomously for Hours — GPT-5-Codex can run for seven hours unsupervised, but the real shift is that it decides how long to think, which moves the engineering bottleneck from writing code to verifying it. What that means for your tests, your AGENTS.md, and your CI.
Autonomous Pentesting: AI Agents That Exploit Bugs Instead of Just Flagging Them — Traditional scanners hand you a backlog of maybes. Strix, an open-source AI pentesting tool, runs autonomous agents that exploit vulnerabilities and prove them with working PoCs. Here's why a demonstrated exploit changes the economics of application security, and how to trial it safely.
How AI Agents Pay: A Practical Guide to the Agent Payments Protocol — AP2 isn't really about moving money. It's an accountability protocol that turns "did the user actually want this?" into a signed, verifiable object. Here's how its Mandate chain works and what to build now.
Profiling by Prompt: Copilot's New Performance Agent in Visual Studio — Visual Studio's Copilot Profiler Agent lets you profile .NET code by asking a question. Its real contribution isn't reading flame graphs for you. It's automating the measure-change-remeasure loop most developers skip, BenchmarkDotNet and all. Here's how it works and where you still own the call.
Testing Your AI's Defenses: Prompt Injection Lessons from Gandalf — Lakera's Gandalf game reveals the real architecture of LLM defenses: system prompt, input guard, output guard, and why each layer leaks. Here's how to turn those lessons into an adversarial test suite for your own AI app.
Prompt Engineering for a Fast, Cheap Coding Model — When a coding model costs a tenth as much and runs several times faster, the old habit of polishing one perfect prompt works against you. A practical guide to prompting xAI's grok-code-fast-1: curate context instead of dumping the repo, structure with Markdown and XML, use native tool calling, keep
Agentic Design Patterns: A Field Guide to Building AI Agents — The patterns that actually recur when you build AI agents: workflows versus agents, the five workflow shapes, the cognitive behaviors, and why the tool interface is where most systems quietly fail.
Building Production Voice Agents with the gpt-realtime API — OpenAI's gpt-realtime moved the Realtime API out of beta with native speech-to-speech, SIP calling, remote MCP servers, and image input. Here's what actually matters when you build a production voice agent on it, and the cost and context realities that don't show up in a demo.
The Hidden Limit of RAG: Why Vector Dimensions Cap Your Dataset — Retrieval quality isn't only a model problem. A single embedding vector's dimension sets a hard, geometric ceiling on how many document combinations it can ever return. Here's the math, the benchmark that exposes it, and what to build instead.
Visualizing Embeddings at Scale with Apple's Embedding Atlas — Apple's Embedding Atlas renders millions of embeddings interactively in a browser tab by shipping DuckDB-WASM, Mosaic, and a WebGPU pipeline to the client. A look at the data-engineering choices that keep exploration honest at scale, plus how to point the CLI at your own Parquet file.
The Lethal Trifecta: Understanding Prompt Injection in AI Agents — Prompt injection isn't a bug in any one tool. It's what happens when an agent holds private-data access, untrusted input, and external communication at the same time. Here's the mental model and how to break the triangle.
Generating UI Components from Figma with the Dev Mode MCP Server — Figma's Dev Mode MCP server does more than turn a frame into markup. It hands your coding agent the design's real structure. Here's how to set it up, which tools matter, and why Code Connect is the difference between a lookalike and code you'd actually merge.
Hosting MCP Servers in Production with FastMCP Cloud — Building an MCP server is the easy part; the friction is everything after mcp.run(): remote transport, auth, CI/CD, and JSON-RPC observability. A practical look at how FastMCP Cloud collapses the deploy step from a repo to a live authenticated endpoint, and where self-hosting still wins.
Building AI Agents in .NET with the A2A SDK — A hands-on look at the A2A (Agent2Agent) .NET SDK: how agent cards, the TaskManager server model, and the message-vs-task split let a .NET agent discover and talk to agents built in any stack.
No-Code AI App Builders: A First Look at Google Opal — Google Opal turns a plain-English sentence into an editable graph of chained LLM calls. Here's what that visual DAG editor is genuinely good for, and where an engineer should stop trusting it.
AI in Your Git Workflow: Copilot Commit Messages and Code Review — GitHub Copilot now writes your commit messages and reviews your pull requests. After living with both, here's why one deserves near-autopilot and the other should never be a merge gate, and why context is what separates useful from bland.
Building AI Agent Teams with Claude Code Sub-Agents — Your main context window fills with test dumps and grep sweeps you'll never reread. Claude Code sub-agents fix that by splitting work across specialists, each with its own context window, tool budget, and one job. A practical guide to defining them, scoping their tools, and chaining them into a team
Running LLMs Locally: Ollama vs LM Studio — Ollama and LM Studio both run open models on your own hardware over llama.cpp, but one is a background service you build against and the other is a GUI workbench for auditioning models. A practical breakdown of the CLI, the OpenAI-compatible API on both, and when to reach for each.
Prompting GPT-5: A Practical Guide for Developers — GPT-5 takes your instructions literally, so prompting shifts from clever phrasing to setting the right dials and deleting the contradictions you never noticed. Here's how to do both.
Building a RAG System with Local Vector Search — A hands-on guide to RAG on your own hardware: chunking, open embeddings, a local vector store, retrieval, reranking, and wiring it to a model.
From Manual Testing to AI-Generated Automation with MCP — Chain an Azure DevOps MCP server with a Playwright MCP server into one agent that turns manual test cases into runnable automated tests.
Ask Mode vs Agent Mode: Getting the Most Out of GitHub Copilot — When to reach for GitHub Copilot's conversational Ask mode versus autonomous Agent mode, with concrete .NET scenarios for picking the right one.
Verification-and-Refinement: How Standard LLMs Reached IMO 2025 Gold — How researchers matched IMO 2025 gold with a standard LLM: not by scaling the model, but by wrapping it in a verify-and-refine loop.
Azure Cosmos DB Core (SQL) API — A deep-dive into Azure Cosmos DB's Core (SQL) API - the native NoSQL engine that gives you the power of JSON + SQL with automatic scaling, rich queries, and global availability out of the box.
Top 5 hidden .NET components — Even seasoned developers might overlook some of the subtle yet powerful features introduced in recent .NET versions. Let's uncover five such hidden gems that can enhance your development experience.
5 architectural tests — You write unit tests to validate behavior - but what if you could write tests to enforce architecture? See some concrete examples.
Genspark AI: New Super Agent — Phone calls, Data Analysis, Video creation, Trips planning... That's what Genspark AI promises. So, I gave it a shot. Read more in this article.
Azure Cosmos DB: Introduction — Curious about what makes Cosmos DB a go-to solution for globally distributed NoSQL workloads? Here is a first introduction to Azure Cosmos DB.
Your Essential Guide to Health Checks in .NET — Health monitoring isn't optional in modern systems - it's essential. That's why I put together a comprehensive guide to Health Checks.
Claude Code: Anthropic's AI Coding Assistant — Ever wished to start Vibe Coding? Say hello to Claude Code, Anthropic's new AI coding assistant - and your future terminal sidekick.
Code-First vs Database-First - which camp are you in? — There are two common approaches to friendship between your application and database. Let's review.
Agile Planning Poker ♣️ - more than a Game for Estimates — Tired of sprint surprises and mismatched estimates? Say hello to your team's new favorite planning ritual: Agile Estimate Poker. Level up your sprint planning game!
Get started with the official Microsoft's Azure MCP Server — Ready to talk to your Azure resources like you talk to a teammate? Big news: Microsoft's Azure MCP Server is now in public preview - and it's about to change the way we interact with Azure using AI.
Concurrent Collections in .NET: A Practical Cheat Sheet — There are various approaches to manage concurrency in your .NET application. One of them is utilizing concurrent collections. Check them out.
Agentic AI implementation guidance — This guide is based on a 32-page practical manual on agent development shared by OpenAI. Inside, you'll find theoretical foundations, design patterns, best practices for safe deployment and monitoring and a wealth of real-world examples.
Regex in .NET: Patterns, Performance, and Clean Code — Regex might look like gibberish at first - but once understood, it's a superpower for pattern matching, data extraction, validation, and transformations.
Microsoft Copilot Studio: a Low‑Code AI Assistant Builder — Whether it's for HR, customer service, or IT support - Microsoft Copilot Studio is a game-changer for businesses looking to harness AI in a practical way.
MCP Explained: Empower your AI — Integrating AI models with diverse data sources and tools can be complicated. The Model Context Protocol (MCP) simplifies this process, helping you seamlessly connect AI to external tools and data.
APIs Overview: REST, GraphQL, and gRPC — Developers now have many options when choosing how to build APIs. Let's review the common ones.
Azure Storage: Blobs, Queues, Tables, Files, Security & Cost — Azure Storage is Microsoft's cloud-based solution for storing and managing large amounts of data - everything from simple text logs to huge media files, backups, or structured tables.
Thread Safety in .NET: lock vs SemaphoreSlim vs Mutex — Ever wondered how to keep your multi-threaded applications safe and sound? I dive deep into the mechanisms that make thread safety possible in .NET.
Vector Databases in AI/ML: the next-gen infrastructure for intelligent search — Vector databases are transforming how AI retrieves and understands information. Whether it's LLMs using RAG, AI-powered search, or real-time personalization, they're becoming essential for intelligent systems.
Agentic AI: the rise of autonomous agents — Imagine an AI that doesn't just respond but acts - scheduling meetings, managing workflows, even handling customer requests on its own. That's Agentic AI, and it's already changing how we operate.