Articles
Engineering that holds up in production
Long-form articles on .NET, Azure, databases and AI systems. Each one explains a mechanism, shows code that has been run, and names the trade-off.
-
RAG That Keeps Its Evidence: Eligibility, Coverage and Licensed Claims
Filter before Top K, check that the selected set covers every required fact, accept only sentences their citations license, and carry an evidence identity into the next stage.
-
When an Agent Coordinator Has a Real Choice
Drop selector calls where the dependency graph already decides, keep a checked selector only at a real fork, and charge every attempt so a fluent loop that makes no progress still stops.
-
Human Approval After a Restart: One Reviewed Proposal, One Local Effect
Bind approval to the exact draft, evidence and policy, resume a pending review from an Agent Framework checkpoint in a new process, and recover a lost receipt without a second effect.
-
Native Decision API Clients in C#: Wire Shapes and Stalled Bodies
Build one C# client for System One and OpenAI Decisions that maps answers by meaning, parses strictly, owns one deadline past the headers and reports every failure as a distinct outcome.
-
Azure Decision APIs: Root, Deployment, Operation and Token Audience
Microsoft-Decision-1 and Azure OpenAI Decisions use different paths, serializers and token audiences. Bind each to one validated C# profile and keep the token inside the deadline.
-
Local Models and Polish Routing: Evaluate the Errors, Not the Average
A local model changes where inference runs, not what its scores mean. Evaluate English and Polish pairs, separate agreement from correctness, and see why a margin threshold misleads.
-
Designing a Decision Contract That Preserves Meaning in C#
Write the rubric first, give choice, predicate and score their own C# types, and reject what a JSON schema cannot see: missing candidates, inconsistent means and duplicate keys.
-
Decision APIs: Derive the Threshold From the Cost of Each Error
A probability is not an action. Derive automation and review thresholds from error costs, model imperfect reviewers, rank a scarce queue and check what calibration must hold.
-
Decision APIs in .NET: One Judgment Inside a Working Support Desk
Give a model one bounded question, which team investigates first, and let C# policy decide the action. A small Agent Framework workflow shows six tickets stopping for six reasons.
-
What a Decision Probability Actually Computes: Logits to Labels
The same {"department":"technical"} can come from generation, a classifier or label scoring. Work through softmax, candidate sets, multi-token labels and schema masks to see what 0.88 means.
-
Trace an Agent SQL Tool from Its Request to the Rows Read
Five Index Seeks return the same 1,000 rows and three read 5,000. Follow an agent tool's parameter into the actual plan, read the right counters and attach the query to the answer.
-
A Link Is Not a Citation: Pin the Claim, the Bytes and the Date
A real .NET release note kept its November heading while a December SDK appeared under it. Build a small C# resolver that binds each claim to a pinned revision, a hash and a review.
-
Telemetry Event Formats: Units, Versions, Bytes and CPU in .NET
A strict C# telemetry codec followed byte by byte: why a tolerant JSON reader turns 1.5 ms into 1.5 s, and what Brotli, buffers and decoders really cost on .NET 10.
-
Why Your .NET Payload Survives: Trace the Roots, Unlink and Drain
Follow the strong path that keeps a 16 MiB payload alive on .NET 10, find the second owner behind an unsubscribed event, and build a subscription that unlinks and drains safely.
-
Verify the Statistics Your SQL Maintenance Job Actually Changed
A green UPDATE STATISTICS job can refresh the wrong table, sample when you asked for a full scan, or be undone by an automatic update. Check the object you meant, by id, and say unknown when unsure.
-
Keep the Failed Attempt: Retry History, Late Events and Retention
A retry that overwrites one status row erases the timeout before it, and a late report can undo the success. Build an attempt ledger in SQL Server that keeps both and survives retention.
-
Indexing JSON in SQL Server 2025: Typed Keys, Real Plans, Write Costs
A computed-column index and the new JSON index both turn a 4,100-page scan into a few reads, but each stores its own meaning of a value and makes every update pay. Measured on SQL Server 2025.
-
Hash Aggregate Spills: Read the Memory Grant Before Tuning It
A SQL Server 2025 hash aggregate spills despite an overestimate. Six measured fixes show why a better estimate made it worse and which change removed the spill.
-
SQL Date Filters: Keep the Business Day and Count the Rows Read
Compute 23-hour and 25-hour local days at both ends, filter with typed half-open intervals, and see why a CONVERT(date) seek still read twice the rows on SQL Server 2025.
-
Same Service, Different Numbers: A Measurement Contract for .NET
One FrozenDictionary measured 42% faster, 6.5 times slower, or 347 µs instead of 89 µs. Reproduce all three on .NET 10 and learn what every performance number must state.
-
Vector Search Under Pressure: Distance, Candidates and Index Updates
When a relevant document is missing, the metric is rarely at fault. Measure what post-filtering, candidate budgets and stale index membership do, on SQL Server 2025 and in C#.
-
ASP.NET Waits with Low CPU: Find the Queue Before Changing the Pool
The same endpoint can queue at a semaphore or inside the thread pool. Read the counters and a real stack, measure what async changes, and build a permit gate that cannot leak.
-
Fast Responses, Old Inventory: Freshness from Source Event to Blazor
A 304 can be correct and still show the world before the delivery. Separate source, accepted and published versions, order the HTTP checks, and measure age as an interval at the screen.
-
Restartable .NET Ingestion: Stage Chunks, Publish Complete Revisions
Keep a half-imported revision out of search: chunk by structure, key embeddings by content, stage in SQL Server 2025 and publish a whole revision by moving one pointer.
-
The Observer Effect: What .NET Telemetry Costs Before Sampling
A sampled-out span can still build its payload, and a stalled exporter silently drops spans. Measure both with OpenTelemetry .NET and add the guards and counters that fix them.
-
AI Can Finish the Task and Still Leave the Junior Developer Behind
Finishing a task, explaining it and adapting it are different skills. What controlled studies show about AI help and learning, and a mentoring practice that keeps the speed.
-
Why Publish Technical Writing When AI Can Explain the API?
An assistant answers the question you asked. An article chooses the question, gives a claim an address others can challenge and puts rare cases back into the public record.
-
A SQL Diagnostic Is a Product: Version the Query, Schema and Rule
A stale-statistics check can fail green: absent fields read as zero, filtered statistics and the wrong target. Version the collector, schema and rule, and make Unknown useful.
-
Disagree with the Assumption, Then Shrink the Counterexample
A sensible "normalize to UTC" review comment changes a customer's requested day. Use an independent anchor, a real FsCheck run and its shrinking to turn disagreement into a fix.
-
More Agents Will Not Decide What Your Price Means
Four plausible parts turn EUR 19.90 into EUR 0.20 and then a free item. A runnable repair shows why one narrow, complete slice should come before parallel work, human or agent.
-
What Technical Judgment Looks Like When AI Knows the Syntax
Two runnable .NET cases: an invoice total that depends on where it rounds, and a timeout that frees a semaphore permit while the work still runs. Judgment is finding the question the API leaves open.
-
Measure the AI Review Queue Without Inventing Reviewer Effort
Delivery times are not lead times, elapsed is not effort, and five approval notifications can be three accepted tasks. Measure the review queue honestly, then model capacity.
-
Your AI Chat Cannot Carry the Team's Architecture
A clean invoice rename breaks a monthly export because the reason lived in an old chat. Record the decisions agents would erase, make them executable, and put them where work starts.
-
Due Diligence on an AI Agent: Follow "Read-Only" to the Database
A read-only SQL agent refused a DELETE in the demo. Follow that claim to the database: which control refuses, what the reply hides, and how to size the verdict for a founder or investor.
-
The AI Draft Passed Its Checks. Now Make the Product Decision
A schema check passes an unsupported AI judgment. Read one feature as engineer, founder and user, with runnable C#, overreliance research and a decision you can reverse.
-
An AI Investment Thesis Should Change When the Evidence Does
Read an AI startup's thesis as a ledger of claims: why selected demos are not samples, which denominator a unit cost hides, and how to tell honest narrowing from moved goalposts.
-
When Code Gets Cheap, the Scarce Part Is the Promise Around It
AI cuts the cost of a first version, not of checking, upkeep and exit. An effort model, the measured speed-ups and three products built on one codebase show where value moves.
-
When the Model Becomes a Commodity, What Does the Business Still Own?
A cheaper model can replace yours behind the same adapter. Test the swap on the cases customers pay for, then find the complements a full export would not take with it.
-
Give Human Oversight a Decision It Can Still Change
An approval button does not create oversight. Place the decision before the effect, bind it to the exact proposal, show the change beside its record and write the reviewer's job down.
-
Ready for Which AI Responsibility? Readiness Is a Set of Evidence Gaps
A support assistant can be ready to search manuals and unready to change an order. Map each responsibility's requirements, keep their states apart and recheck only what a change touched.
-
A Worker Appeals the Queue: What Must Change Before the Shift Ends
Every queue objective chooses who waits. Follow one disputed case from ranking to appeal to scorecard, and see which correction actually reaches the worker's afternoon in time.
-
AI Pilots That Can Fail Usefully: Compare Honestly, Rehearse the Exit
Design an AI pilot whose guardrails are fixed before the data, read a mixed result without spin, and rehearse stopping so every order it touched gets an owner.
-
Automating a Task Does Not Decide the Job: Follow the Saved Time
An AI-drafted reply promises a delivery on a holiday. Follow it through the sending rule, then follow the saved minutes into three organisations that a manager, not the model, chooses.
-
AI Makes Drafting Faster. Why Is the Team Still Waiting?
Follow twelve changes through drafting and review: a fourfold drafting speed-up saves real effort, barely moves delivery and doubles the queue. What studies measure, and how to measure yours.
-
One Million Events and Three Ways a Consumer Quietly Breaks
Duplicates after a lost acknowledgement, events skipped by a high-water checkpoint, and old events reapplied after retention: why totals miss them and how one transaction prevents them.
-
Buying an AI Product: What the Demo Quietly Gives You for Free
Two AI products write equally convincing release notes. Price the accepted result instead of the generation, find the one assumption that flips the decision, and pilot exactly that.
-
The Cost of One Task on Azure: Metered, Allocated and Reconciled
Azure bills resources, not tasks. Measure model tokens per task, pick billed or amortized cost, allocate shared cost by a named policy in exact cents, and reconcile with the meter.
-
Why This Total Changed: Lineage That Survives Retries and Corrections
Give every derived total an identity from its rule and exact source versions, record each contribution, and correct sources by replacement, so retries count once and changes explain themselves.
-
When SQL Monitoring Becomes the Workload: Scans, Viewers and Locks
A four-row dashboard tile can out-read the business it watches and queue writers behind its own lock wait. Measure the per-call cost, share one snapshot and bound the exporter.
-
Trace One Order Across HTTP, a Queue and Retries in .NET 10
Make an ASP.NET Core 10 service explain itself before the first incident: propagate context through a queue, keep failed retries visible, and know what survives when traces are sampled out.
-
Async Work Is Not on the Thread Stack: Tracing Suspended .NET Code
Why a live stack cannot show awaiting callers, how .NET 11's async profiler records the continuation chain instead, and why request identity must come from your own trace ID.
-
Moving Large Datasets with EF Core: Bounded, Resumable Batches
Export millions of rows through an EF Core 10 service without skipping or duplicating any: a frozen selection, keyset pages, a bounded pipeline and a receipt that commits with the data.
-
Deployer, Runtime, Operator: Three Azure Identities and One Cache Key
Follow four tokens through one Azure service: audience checks, workspace membership, a cache key that leaks across tenants, and why publishing code is data access.
-
A Performance Diagnosis That Survives the Allocation Explanation
Allocation fell 77% and latency did not move. Test competing explanations on a real ASP.NET Core and SQLite endpoint, read the statement's work, and hand over a decision.
-
Telemetry Is a Schema: One Contract for a .NET AI Platform
A library upgrade renamed gen_ai.system and zeroed a dashboard. Build a .NET telemetry contract that survives GenAI convention changes, retries and cardinality limits.
-
Move ONNX Inference Behind HTTP Without Changing the Computation
A matching signature and a unit-length vector prove little. Pin the MiniLM pipeline, fix three .NET tokenizer differences, pool with the mask and know what a tolerance guarantees.
-
From AI Draft to Accepted Work Order: One Service, Real Review
A complete-looking AI draft can pass every validator and still overstate its evidence. Route forms and IChatClient through one service and bind approval to revision and evidence.
-
The Agent Timed Out. Did Its Approved Action Happen?
Bind approval to the exact proposal, consume it atomically, persist Unknown before sending, and reconcile or fence at the receiver instead of retrying blind. In C#.
-
A Real Citation, a Wrong Answer: Check Claims, Scope and Time
A cited number can still answer the wrong question. Check each claim against its fact on property, scope, unit and two clocks, and keep honest partial answers useful.
-
Semantic Kernel to Agent Framework: Migrate Behavior, Not the Calls
Moving a reservation tool from Semantic Kernel to Microsoft Agent Framework: keep identity and authority in a service, test against existing state, and keep lost replies unknown.
-
When an Agent Says Done: Resolve Each Claim Against What Was Delivered
A passing test run survived a filter edit and the receiving import never ran. Track claims with their subjects so the next session knows what is valid, stale, failed or missing.
-
What Does a Correct RAG Answer Cost? Count Retries, Review and Setup
Per-call price ranks RAG pipelines wrongly. Divide all work by accepted tasks, keep missing usage unknown, and see how volume and question mix change the winner.
-
A Read-Only SQL Agent Must Survive a Forbidden Command
Build a SQL Server diagnostic tool that stays read-only when the model misbehaves: a fixed tool catalogue, a narrow principal, a pinned tenant and real cost limits.
-
One Question, Several Queries: Typed Intent Between Language and SQL
Let the model propose meaning, not SQL. Parse a small typed intent strictly in .NET 10, compile it to reviewed templates, enforce the tenant in SQL Server and return results that say what they count.
-
Copilot Studio over Direct Line: Track Accepted Work, Not Chat Bubbles
A Direct Line page is a batch of activities, not an answer. Build a .NET client that keys acceptance by task, keeps the watermark opaque and commits each page atomically.
-
Upgrade Microsoft.Extensions.AI by Testing the Seams You Actually Use
A one-line package bump from 9.10.2 to 11.0.0 compiles and passes tests, yet the text the model reads after a rejected approval changed three times. Build a tracker that notices.
-
After the Restart: Reconcile a Lost Acknowledgement in a .NET Agent
The receiver committed, the response was lost and the agent restarted. Persist the obligation, bind a receipt to the effect, reconcile by key and know when to stop replaying.
-
A Verified SQL Backup Is Not Yet a Recovered Application
VERIFYONLY passed, CHECKDB was clean and the invoice service still failed. A SQL Server recovery drill that checks history, logins, TDE keys and the real operation.
-
Why an Agent Keeps Replanning: Build a Loop That Can Stop
Rephrased plans are not progress. Build a C# controller that separates new facts from new wording, refuses stale commits and ends every agent run with a typed reason.
-
The Real Cost of an AI Agent: Count the Work That Failed
A cheaper model call can still make accepted work more expensive. Build a C# cost ledger that counts failed attempts, divides by accepted tasks and keeps unknown usage unknown.
-
An Agent Tool Is an API: Caller Authority, Receipts and Lost Replies
Treat agent tool calls like public API requests: take identity from the host, scope tools per request, store receipts with the effect and replay lost replies.
-
RAG in .NET: retrieve the policy the caller can actually use
Build the retrieval side of RAG in C#: eligibility before top-k, grants and revisions in the query, chunks that keep their exceptions, and atomic revision publishing.
-
RAG or Broad Context: Was the Evidence Missing or Ignored?
The same wrong answer can mean the source never reached the model or the model ignored it. Score the packet and the answer separately in C# to know which part of the pipeline to fix.
-
Agent Spending Authority: Reservations, Approvals, Uncertain Charges
Two agent tools read the same balance and both spend. Reserve capacity atomically in C#, bind approvals to one operation, and keep units held until the destination confirms the charge.
-
A 403 Is Not Enough: Mutation-Test Agent Tools at the Effect Store
A refused agent tool call can still commit its row. Run an ASP.NET Core endpoint over real HTTP and SQLite, plant five mutants, and see which assertions catch them.
-
A Citation Is a Pointer: Executable Checks for RAG Claims in C#
An exact citation can carry a wrong number, a misread exception or a lifted prohibition. Compile the policy into facts and verify typed claims in C#, with honest verdicts.
-
Reset an Agent's Memory Without Losing Its Commitments in .NET
Conversation, read cache, domain rows and receipts have different owners. Reset an Agent Framework session, replay a SQLite reservation and get the original receipt back.
-
A Timeout Is Not Cancellation: WaitAsync, WhenAny and Lost Commits
Why Task.WaitAsync and Task.WhenAny end your wait but not the work, and how an owner, a shared deadline and a stored receipt keep a timed-out reservation from happening twice.
-
Streaming AI Answers in Blazor: Stop Old Requests Rewriting the View
A late chunk, an old validation verdict or a stale cleanup can corrupt a streaming Blazor answer. Guard every await, define Stop, throttle renders and test the orderings.
-
Refactor a Pricing Function Without Rewriting Its Rules
Pin a small C# pricing function with hand-calculated contract tests, refactor it with behavior frozen, make a one-predicate change and prove the tests catch real mistakes.
-
Reusable ValueTask Sources: When Is It Safe to Call Reset?
Build an IValueTaskSource that survives reuse: release in GetResult, reserve completion before SetResult, and stop an inline consumer from breaking the next operation.
-
ArrayPool Across await: Leases, Ownership Transfer and Real Savings
Reproduce the HELLO-to-WORLD overwrite with ArrayPool.Shared, end leases at the right event, transfer ownership through a bounded queue and measure what pooling really saves.
-
Parsing TCP Frames in .NET: Cursors, Backpressure and Buffer Lifetimes
Build a framed PipeReader loop that survives split headers, see why Pipe backpressure counts examined bytes, and decide from measurements when copying beats a borrowed slice.
-
RAG Quality Is a Distribution: Evaluate Each Question Type in .NET
A higher average RAG score can hide a slice that got worse. Tag cases by question type, compare candidates by flips, size slices for the decision and gate releases per slice in C#.
-
Database Cutover: Fence the Old Writer Before You Move the Endpoint
A client timeout, a stale connection and a green probe can still split your history. Reconcile by operation key, fence the old writer inside the database, then route.
-
Modernize an ASP.NET API Without Rewriting Its Wire Contract
A rewrite can return 200 and still break every client: enums, UTC dates, rounding, JSON types and nulls. Pin the contract with examples, adapt at the wire and rehearse rollback.
-
Reservation Confirmed or Work Accepted: What 201 and 202 Promise
A 202 promises an operation, not a reservation. Build both designs on SQL Server: idempotent admission, a claim that really skips locked rows, and leases fenced by generation.
-
Why .NET 11 Removes This Box, but Keeps That Allocation
One binary on .NET 10 and .NET 11: nullable boxes that stay local stop allocating, escaping boxes and closures do not. Read the JIT code and the measurements behind each case.
-
Runtime Async in .NET 11: Who Builds the State Machine Now?
In .NET 11 the JIT, not the C# compiler, can implement async methods. Read the IL and x64 it produces, and see what changes for completed and suspended calls.
-
Who Owns AI-Written Code When Everyone Reviewed Something Else?
A three-line cleanup patch deletes pinned files after four green checks. Follow the hand-offs, find the one test that stops it, and give ownership real information and control.
-
The Hidden Network Work of a Blazor Search Box
Out-of-order responses, stale errors and abandoned server work in a Blazor search box, reproduced on .NET 10, and a component where debounce, cancellation and a generation each do their job.
-
Semantic Search in Blazor WebAssembly: Where the Cost Moves
Run an embedding model in a Web Worker behind a Blazor component, then follow the cost it moves: a 90 MB first visit, exact tokenization and pooling, stale results, caching and cleanup.
-
Lazy<T> Under Contention: Racing Factories, Cached Failures, Blocked Threads
What each LazyThreadSafetyMode really does on the first call: losing factories that keep their side effects, exceptions cached forever, blocked callers, and an async cache that recovers.
-
Permission Changed Mid-Answer: Gate the Write, Not Just the Check
A streamed answer that checks permission on every chunk can still leak after revocation. Gate the write, choose a snapshot contract deliberately, and keep retrieved text out of your logs.
-
A recovery runbook should refuse the wrong next step
A SQL Server restore that verifies, opens and answers queries can still be the wrong database, miss a committed write or load the wrong file. Make each check permit exactly one next step.
-
Azure Service Bus and agents: persist the event, then claim the work
Commit the inbox before completing the message, deduplicate events and work separately, and recheck version and permission when a worker claims the job, so redelivery never runs an agent twice.
-
A Minimal .NET Agent Platform: Four Jobs, Two Workers, One Restart
Stop a small ASP.NET job service while it still owns work, then restart it. Four jobs show what can resume, what must wait, and what only the receiver's receipt can settle.
-
Executable Deployment Recipes: Prove the Result, Own the Cleanup
A recipe that starts is not a recipe that works. Separate ready from accepted, own every process with a job object, keep cleanup errors, and date the last accepted run.
-
ASP.NET Core Behind a Proxy: The Redirect Loop and the Lost Prefix
Why an app behind a TLS-terminating proxy redirects HTTPS to itself or links to the wrong path, and how to restore scheme, client IP and prefix without trusting forged headers.
-
Azure Blob Downloads in .NET: Buffers, Ranges and Safe Publication
Copy arrays, transfer sizes and OpenRead buffers are three different knobs. Real SDK calls show what each one sends, what 12.30 buffers in memory, and how to publish only verified bytes.
No article matches that search yet. Try a broader term, or suggest a topic.