Articles
AsiBackbone Learning articles are standalone technical arguments written for direct discovery, sharing, and citation. A reader can arrive from a search engine, newsletter, social link, conference resource list, or external reference without completing the Learning curriculum first.
Start by Topic
| If you are interested in... | Start with |
|---|---|
Choosing AddTransient, AddScoped, or AddSingleton, captive dependencies, a singleton holding a DbContext, scope validation, scopes in a BackgroundService, disposal, and IDbContextFactory |
Your Dependency Injection Lifetime Is an Ownership Decision |
Fire-and-forget Task.Run in an endpoint, BackgroundService and bounded channels, request-scoped services in background work, shutdown and restart losses, and what 202 Accepted promises |
Task.Run Does Not Make ASP.NET Core Work Durable |
| Canceling a queued or running job, a cancellation that races the worker claiming it, stopping work already underway, and what to record when cancellation is too late | Canceling a Queued Job Can Race With Execution |
| A payment provider call that timed out, whether the customer was charged, idempotency keys after a lost response, and resending versus reconciling | A Payment API Timeout Leaves the Outcome Unknown |
| One-time grants or capabilities accepted twice across application instances or after a restart, and what a shared, durable, atomic consumption store must guarantee | An In-Memory Grant Store Is Not Distributed Replay Protection |
| Reconstructing what happened across an API, queue, worker, and webhook, correlation IDs versus trace IDs, duplicate and out-of-order delivery, and sampled traces as evidence | A Correlation ID Is Not a Distributed Audit Trail |
| Authenticated requests whose account IDs, tenant values, prices, or status fields are still untrustworthy, over-posting, and object-level authorization | Passing Authentication Does Not Make Input Trustworthy |
| Approvals and authorization checks that go stale before delayed execution, time-of-check to time-of-use, and which changes should invalidate a decision | Your Security Check Passed. Then the World Changed. |
What identity and authority should cross from an ASP.NET Core request to a queued job or BackgroundService |
A Background Job Should Not Inherit Everything the User Could Do |
| Choosing which layer of a .NET application should authenticate, decide, and enforce, and covering every entry path to a side effect | Where Should Authorization Live in a .NET Application? |
| AI coding agents that find adjacent work outside their assigned issue | Discovery Is Not Authorization: Using GitHub Issues to Govern AI-Assisted Development |
| Polly, queue, and background-job retries that reuse an earlier authorization decision | Your Retry Logic May Be Replaying an Authorization Decision |
| .NET LTS migrations, template-derived applications, upstream baselines, and isolated upgrade candidates | You Don't Need to Roll Back What You Never Merged |
| Allowed or approved operations that failed, unknown outcomes, retries, and compensation | An Allowed Decision Does Not Mean the Operation Succeeded |
| Idempotency keys, duplicate delivery, capability replay, and ambiguous retries | Idempotency Does Not Prevent Authority Replay |
| Authorization outages, fail-open versus fail-closed, deferral, and degraded mode | Should Authorization Fail Open, Fail Closed, or Defer? |
| Shared background workers, tenant isolation, and workload identity | Can One Worker Safely Execute Delayed Operations for Many Tenants? |
| Workflow engines, approval state, retries, and who owns the execution decision | When Should a Workflow Engine Own the Decision? |
| Delegated authority for background workers, queues, and delayed execution | How Short-Lived Execution Authority Differs from User Authorization |
| Microsoft.AgentGovernance and host application architecture | How Application Architecture Complements Microsoft.AgentGovernance |
| Policy-as-code, policy engines, and remote policy services in ASP.NET Core | Policy as Code in ASP.NET Core Without Overengineering |
| Authorization, approval, acknowledgment, and delayed execution | Authorization vs. Approval vs. Acknowledgment: Which Decision Do You Actually Have? |
| Validating AI tool calls before execution | What Should an AI Tool Gateway Validate Before Execution? |
| MediatR pipeline behaviors, decorators, and authorization boundaries | Your Pipeline Behavior Can Watch the Operation. It Should Not Decide It. |
| AI-assisted development and maintainer authority | A Passing Agent Diff Is Not Project Authority |
| Audit evidence and decision provenance | Your Audit Log Records the Story, Not the Decision |
| Capability tokens, roles, and claims | Do You Need a Capability Token, or Are Roles and Claims Enough? |
| AI tool execution and host authority | Why an AI Tool Call Is a Proposal, Not Authority |
| ASP.NET Core authorization versus governed execution | When ASP.NET Core Authorization Is Not Enough |
| Testing protected execution boundaries | How to Test That a Denied Operation Never Executes |
| NuGet package trust and software supply chain evidence | A Green CI Badge Does Not Prove Your .NET Package Is Trustworthy |
| Authorization timing and resource-state decisions | Your Authorization Check Runs Too Late |
Prefer new articles as they are published? Subscribe to the existing Learning RSS feed.
Publication Model
Articles are not curriculum stages and do not require prior Learning material.
Each published article keeps a stable year-and-slug address:
https://asibackbone.github.io/Learning/articles/<year>/<slug>.html
Once released, that URL is treated as permanent. Reorganizing tutorials, architecture pages, security material, or other curriculum content does not move an article.
The Learning site is the canonical publication host. Cross-posted copies should point back to the Learning article when the external platform supports canonical attribution.
2026 Archive
Your Dependency Injection Lifetime Is an Ownership Decision
Christopher D. Cavell · November 19, 2026
An online store cached exchange rates in a singleton that received the request-scoped EF Core DbContext, and for most of a day its two instances showed the same cart at different prices, while some requests failed with an EF Core concurrency error that nobody could reproduce. Scope validation would have refused the registration, but the team's environment was not named Development. This guide describes transient, scoped, and singleton by who shares an instance, how long it and everything it holds stay alive, whether concurrent requests reach it, and who disposes it; separates an instance's lifetime from the lifetime of the data it holds; shows what scope validation catches and what it cannot see; rejects two opposite repairs, making everything scoped and promoting services to singleton to save allocations; gives one small application a stateless mapper, a request-scoped service and DbContext, a thread-safe singleton cache built on immutable snapshots, and a BackgroundService that creates and disposes a scope for each refresh without becoming a service locator; explains request and explicit scopes, disposal ownership, and when IDbContextFactory<TContext> is the right tool; tests the real registrations with validation on and checks only the instance identities the design depends on; offers a six-question decision guide with a reasonable case for each lifetime; and states what a lifetime does not provide: durability, authorization, caching semantics, or coordination between instances.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/dependency-injection-lifetime-is-ownership-decision.html
Task.Run Does Not Make ASP.NET Core Work Durable
Christopher D. Cavell · November 17, 2026
An accounting application made a slow month-end statement endpoint responsive by starting the work with Task.Run, discarding the task, and returning 202 Accepted. A routine deployment then ended fourteen statements without an error or a log line, and a later change made statements fail with an unlogged ObjectDisposedException because the detached work used the request's DbContext. This guide separates detached work, host-managed execution, and durable acceptance; explains why detached work must resolve its services in a scope created for each work item; builds a bounded in-memory queue processed by a BackgroundService that refuses work when full, records each item's failure without letting cleanup errors hide it or stopping the host, closes admission when the worker is told to stop, and reports what it never started; states what that design guarantees, under which conditions, and what it may lose; gives deterministic tests for a full queue, a failed work item, work still pending when the host stops, and admission closing at shutdown, with every fake and helper in an appendix; explains what 202 Accepted does and does not promise and why the response needs a stable identifier and a status resource; sketches storing the job before answering and when a separate worker or scheduler is justified; compares the options by completion, restart survival, latency, backpressure, and operational cost; and describes the simplest valid design for work that can safely be lost.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/task-run-does-not-make-aspnet-core-work-durable.html
Canceling a Queued Job Can Race With Execution
Christopher D. Cavell · November 14, 2026
A support engineer canceled a queued contact export and was told it had been canceled, while a worker that had already read the job as queued overwrote the cancellation 21 milliseconds later and uploaded 48,112 contacts to a partner whose contract had ended. This guide separates broker delivery, the job's current state, the authority to start, and execution already underway; explains why re-reading the status, deleting the message, and disabling the button narrow the window without closing it; shows a conditional claim and a competing conditional cancellation on the same row, so at most one can move the job out of the queue and "canceled while queued" has a precise meaning; adds a second conditional write that authorizes delivery before the first effect that cannot be undone; treats cancellation after the claim as a request the worker honors only where stopping is safe; records every cancellation request, under a locked row and a client-supplied ID, with the state and attempt it found; states what recovery must not do; tests that hold one writer's transaction open while the other waits; and when one conditional update is the whole design. A companion implementation reference carries the schema, single-statement claims, leases, recovery, the outbox and sweeper, the complete worker and cancellation methods, and a wider test matrix.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/revoke-job-after-it-enters-queue.html
A Payment API Timeout Leaves the Outcome Unknown
Christopher D. Cavell · November 13, 2026
A store's checkout call to a payment provider timed out, the provider charged the card 1.8 seconds later, and the store told the customer the payment had failed; the customer paid again under a fresh idempotency key and was charged twice, while the provider's notification for the first charge was discarded because nothing could match it to the order. This guide explains what a timeout does and does not tell you; why an unknown outcome is its own state, separate from failure; what to persist before the first send; the order of operations that sends each attempt at most once and survives double clicks; classifying responses by the provider's documented semantics; resolving an unknown attempt through notifications, lookups by your own reference, and settlement records, and why "not found" is not "not charged"; the conditions under which resending with the original idempotency key is safe; resilience handlers and SDKs that already retry; what fulfillment, inventory, cancellation, and support do meanwhile; tests for the unknown path; and when a simpler design is enough. A companion implementation reference carries the full schema, endpoint, notification handler, recovery loop, and test matrix.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/payment-api-timeout-unknown-outcome.html
An In-Memory Grant Store Is Not Distributed Replay Protection
Christopher D. Cavell · November 11, 2026
A support application consumed one-time credit grants in a thread-safe ConcurrentDictionary, and a customer still received the same $250 credit twice: a retry after a gateway timeout reached a second instance whose memory had never seen the grant, and a rolling restart erased the record on the first. This guide shows why process-local atomicity does not extend across instances or restarts; why sticky sessions, a distributed cache, and short expiry narrow the gap without closing it; the minimum contract a production store must meet and the application features around it; one write that checks expiry and revocation, claims the grant, and records the operation; where admission belongs and how retries and recovery work; how replay protection differs from idempotency and exactly-once external effects; what to do when the store is unavailable; how long to retain consumption records; tests that model several instances and restarts; and when an in-memory store is the right choice.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/in-memory-grant-store-is-not-distributed-replay-protection.html
A Correlation ID Is Not a Distributed Audit Trail
Christopher D. Cavell · November 8, 2026
One correlation ID connected every log line behind a disputed order cancellation, and the team still told the wrong story. Two shipments read as one retry, a rejected hold read as a transient conflict, and the partner's webhooks and a sampled-out trace never appeared in the search. This guide separates what a correlation ID supports from what readers conclude from it; gives decisions, intended effects, messages, attempts, and external events their own identities; shows what the API, worker, and webhook handler should record at each handoff; handles duplicate and out-of-order delivery without trusting cross-host timestamps; treats sampled traces as navigation rather than evidence; carries identifiers without payloads, credentials, or caller-controlled authority; and shows when structured logs plus durable operation records are enough.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/correlation-id-is-not-distributed-audit-trail.html
Passing Authentication Does Not Make Input Trustworthy
Christopher D. Cavell · November 7, 2026
Every request behind five disputed orders on a wholesale ordering API carried a valid token: last month's prices from a cached mobile build, an account ID a buyer no longer had rights to, a tenant ID from a copied configuration file, a negative quantity, and a status of Approved added by a script. This guide separates what authentication establishes from what the rest of the request claims; sorts every value into identity, selectors, caller-owned input, server-owned facts, and hints; maps malformed, stale, unauthorized, cross-tenant, and adversarial input to the component that owns each; rebuilds the endpoint with a narrow DTO, a validator, one scoped query per resource, server-side pricing, and the client's total as a precondition; explains which token claims can decide access; and shows how little extra work most endpoints need.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/authentication-does-not-make-input-trustworthy.html
Your Security Check Passed. Then the World Changed.
Christopher D. Cavell · November 5, 2026
A sales manager approves a quote that changes a minute before her click, and four days later the offer goes out under a lowered approval limit, after she has changed roles and the customer has been placed on credit hold, because a status flag says Approved. This guide separates the historical truth of a decision from current eligibility to act on it; classifies six kinds of change by whether they need a new decision, a re-read, a re-evaluation, a written policy choice, or no action; explains why invalidating on every change is its own failure; compares re-reading, version binding, event invalidation, expiry, and accepting facts as of the decision; closes the time-of-check to time-of-use gap with a reviewed-terms precondition at approval and a conditional EF Core claim at use; and states when ordinary authorization at the point of use is enough.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/security-check-passed-then-world-changed.html
A Background Job Should Not Inherit Everything the User Could Do
Christopher D. Cavell · November 2, 2026
A report job first forwards the analyst's access token, which expires in a backed-up queue, and then runs under a broad service identity, which produces a statement for an analyst removed from the account, includes bank details their screen masks, and records nobody but the service account. This guide separates requester identity, worker identity, the accepted operation, job delivery, and the check before work starts; explains why a queue message should carry a job identifier rather than tokens, claims, or credentials; follows one Generate Report flow from HTTP request to BackgroundService; classifies which changes should stop a waiting job; covers reusing authorization handlers in a worker, two-actor evidence, delegated access when a downstream service must see the user, and authorizing the finished report against its actual contents; and states when a stored job identifier plus current authorization is enough.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/background-job-should-not-inherit-user-authority.html
Where Should Authorization Live in a .NET Application?
Christopher D. Cavell · October 28, 2026
An invoice-approval feature gains a bulk screen, a chat approval bot, and a nightly auto-approval job, and a clerk ends up approving their own invoices because each entry path carried its own copy of the rules. This guide separates establishing the actor, establishing facts, deciding, and enforcing; compares what middleware, endpoint policies, resource-based checks, pipeline behaviors, application services, domain models, data-access filters, policy engines, and later executors can each see; puts the deciding check where every path to the side effect meets; keeps early checks from rejecting what the decision would allow; and states when an endpoint policy is the whole design.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/where-authorization-should-live-dotnet-application.html
Discovery Is Not Authorization: Using GitHub Issues to Govern AI-Assisted Development
Christopher D. Cavell · October 26, 2026
An AI coding agent assigned to add a CSV export finds a slow query, a possible cross-tenant read, a documentation mismatch, and a refactoring it would prefer, and fixing all four in one pull request lets unreviewed changes ride on an approved one. This guide treats the issue as a work order with an outcome, acceptance criteria, non-goals, and constraints; sorts discoveries into blocking dependencies, separate work, security-sensitive findings, and noise; shows when an agent should stop and ask, propose a linked follow-on issue, escalate privately, or drop a finding; describes what a follow-on issue should carry; explains what GitHub references, sub-issues, dependencies, and closing keywords do and do not guarantee; treats issue text from people without authority as data rather than instructions; and states when a lighter process is enough.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/discovery-is-not-authorization-ai-assisted-development.html
Your Retry Logic May Be Replaying an Authorization Decision
Christopher D. Cavell · October 25, 2026
A background job that creates an external share fails during a provider outage, and its automatic retry succeeds hours later, after the project has been placed under legal hold. This guide explains why HttpClient resilience handlers, Polly pipelines, queue redelivery, and job-library retries decide when an attempt may run again but not whether the earlier authorization decision still applies. It covers how retry layers multiply, putting the eligibility check inside every loop that can outlive the decision, re-evaluating against authoritative state or enforcing explicit decision bounds when re-evaluation is not possible, resending only what is established as safe to repeat, reconciling ambiguous timeouts instead of resending them, keeping a service-credential refresh separate from re-authorization, tests that prove a retry cannot execute under stale authority, and when ordinary retry plus current authorization is enough.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/retry-logic-may-replay-authorization-decision.html
You Don't Need to Roll Back What You Never Merged
Christopher D. Cavell · October 23, 2026
A team derived its service from an upstream template, and the next .NET LTS generation changes the runtime, frameworks, dependencies, and generated structure at once. This guide explains how a preserved upstream baseline, a new baseline generated with the same inputs, and an isolated integration candidate let the team evaluate that generation without disturbing the supported line. It covers the three-way integration model and the Git mechanisms that can carry it out, qualifying the raw baseline before the integrated candidate, separating "runs on the new LTS" from "ready to adopt it," continuing fixes and security updates on main, objective adoption evidence, discarding a failed candidate without reverting anything, what the pattern does not solve, choosing a baseline mechanism, and ReferenceApplication as a bounded case study.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/you-dont-need-to-roll-back-what-you-never-merged.html
An Allowed Decision Does Not Mean the Operation Succeeded
Christopher D. Cavell · October 13, 2026
A merchant-payout suspension is allowed, sent to the payment processor, and times out. This short guide follows that one operation from proposal through decision, authority, claim, attempt, observed outcome, and reconciliation to separate decision truth from execution truth; explains why the historical decision stays Allowed when execution fails; walks through failure before execution, deterministic rejection, a timeout after a possible effect, and a lost completion record; and covers retry versus a materially new attempt, compensation as its own governed operation, a decision/execution matrix, focused tests, and when a synchronous result and ordinary logs are enough.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/allowed-decision-does-not-mean-execution-succeeded.html
Idempotency Does Not Prevent Authority Replay
Christopher D. Cavell · October 12, 2026
A queued refund is delivered twice, and the payment provider times out after accepting the first request. This guide uses that one .NET scenario to separate authority replay, duplicate transport delivery, atomic capability consumption, operation identity and idempotency keys, and inbox/outbox deduplication; explains why reused authority must be rejected even when the operation underneath is idempotent, and why one-use authority does not justify retrying an ambiguously completed side effect; and shows how to record an unknown outcome, reconcile it, and decide when a later attempt is materially new, including when ordinary idempotency is the whole answer.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/idempotency-does-not-prevent-authority-replay.html
Should Authorization Fail Open, Fail Closed, or Defer?
Christopher D. Cavell · October 10, 2026
When a remote policy service times out, the code that called it makes an authorization decision whether anyone designed one or not. This guide follows one ASP.NET Core export endpoint through a policy outage to separate an explicit denial from an unavailable decision, keep timeouts, retries, circuit breakers, and fallbacks from manufacturing authority, choose a per-operation outage treatment of rejection, bounded deferral, escalation, or tightly bounded local evaluation, stop and reconcile when an external side effect may already have happened, and test that nothing protected executes while authority is unavailable, including when a plain "unavailable, try again later" is the whole answer.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/fail-open-fail-closed-or-defer.html
Can One Worker Safely Execute Delayed Operations for Many Tenants?
Christopher D. Cavell · October 6, 2026
Checking that a grant's tenant matches the resource's tenant stops one tenant's delayed operation from being turned into another's, but it does not contain a compromised shared worker that is authorized for every tenant. This guide follows one overnight customer-data export to separate substitution prevention, workload identity, and compromise isolation, shows how the protected host resolves and re-enforces the tenant, explains how to identify a workload unambiguously and handle ASP.NET Core claim mapping, and compares a shared worker with partitioned identities, per-tenant execution, and tenant-bound token exchange, including when the shared worker is the right choice.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/multi-tenant-worker-execution-authority.html
When Should a Workflow Engine Own the Decision?
Christopher D. Cavell · October 5, 2026
A workflow engine can own sequencing, timers, retries, and approval tasks without owning the permission to perform a side effect now. This guide follows one production deployment to show why Approved is not current permission, how to evaluate independently owned policy at the protected execution boundary when work is delayed or retried, and when a workflow that shares one cohesive boundary with the executor can simply own the decision.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/when-workflow-engine-should-own-decision.html
How Short-Lived Execution Authority Differs from User Authorization
Christopher D. Cavell · October 3, 2026
A user's authorization answers whether they may request an operation now; it is not the right authority to forward to a background worker. This guide follows one scheduled vendor payout to show how to delegate only one operation, resource, audience, time window, and use count to a later executor, what the protected host must still check at execution time, and when no extra grant is needed at all.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/short-lived-execution-authority-vs-user-authorization.html
How Application Architecture Complements Microsoft.AgentGovernance
Christopher D. Cavell · October 2, 2026
Microsoft.AgentGovernance gives .NET teams deterministic runtime policy evaluation for agent actions. That verdict is strongest when the surrounding application still owns authoritative context, workflow state, protected execution, failure handling, and evidence. This guide follows one AI-proposed refund through a host-owned control flow and shows where the governance verdict belongs.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/application-architecture-complements-microsoft-agent-governance.html
Policy as Code in ASP.NET Core Without Overengineering
Christopher D. Cavell · September 30, 2026
Policy-as-code is a way to make decision logic explicit, reviewable, and testable, not a requirement to adopt a separate engine or remote service. This guide follows one ASP.NET Core refund endpoint to show when ordinary code or framework authorization is enough, and which real pressures justify an in-process policy component, an embedded engine, or a remote decision service.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/policy-as-code-aspnet-core-without-overengineering.html
Authorization vs. Approval vs. Acknowledgment: Which Decision Do You Actually Have?
Christopher D. Cavell · September 27, 2026
Authorization, approval, and acknowledgment answer different questions, bind to different things, and expire on different clocks. This guide uses one sensitive-data export to show what each decision proves, what it does not, and why none of them should silently become permission to execute later.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/authorization-vs-approval-vs-acknowledgment.html
What Should an AI Tool Gateway Validate Before Execution?
Christopher D. Cavell · September 27, 2026
Structured model output becomes eligible for execution only after the trusted host independently validates its shape, meaning, context, authority, and current permission. This is the ordered checklist, covering approvals, retries, and uncertain outcomes, with tests that prove proposals blocked before execution never reach the executor.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/validate-ai-tool-call-before-execution.html
Your Pipeline Behavior Can Watch the Operation. It Should Not Decide It.
Christopher D. Cavell · September 26, 2026
A generic, operation-agnostic pipeline behavior wraps a call that has already been chosen; it sees the request rather than the resource, cannot express operation-specific outcomes without an operation-specific contract, and can be bypassed by registration order or a second entry path.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/pipeline-behavior-should-not-decide-the-operation.html
A Passing Agent Diff Is Not Project Authority
Christopher D. Cavell · September 13, 2026
A case study of AI-assisted development: two pull requests for an optional X publisher show why passing checks, production evidence, and maintainer authority answer different questions.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/a-passing-agent-diff-is-not-project-authority.html
Your Audit Log Records the Story, Not the Decision
Christopher D. Cavell · September 7, 2026
An audit line written after execution describes an outcome; evidence requires a recorded decision, a binding to the operation it authorized, and integrity that outlives the process that wrote it.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/your-audit-log-is-not-evidence.html
Do You Need a Capability Token, or Are Roles and Claims Enough?
Christopher D. Cavell · September 2, 2026
Use roles or claims when current host authorization is enough; introduce a capability only when narrow authority must survive a later, delegated, or cross-boundary execution step.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/roles-claims-or-capability-token-dotnet.html
Why an AI Tool Call Is a Proposal, Not Authority
Christopher D. Cavell · August 28, 2026
A model may propose a tool call, but valid JSON and a known tool do not create authority; the trusted host still owns context, authorization, credentials, and execution.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/why-ai-tool-call-is-only-a-proposal.html
When ASP.NET Core Authorization Is Not Enough
Christopher D. Cavell · August 26, 2026
ASP.NET Core authorization is often the right answer; add a broader decision/execution lifecycle only when workflow, time, authority, or evidence crosses the request boundary.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/when-aspnet-core-authorization-is-not-enough.html
How to Test That a Denied Operation Never Executes
Christopher D. Cavell · August 26, 2026
A denied result is useful evidence, but a denied result plus zero protected executor calls proves the execution boundary held.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/test-denied-operation-never-executes.html
A Green CI Badge Does Not Prove Your .NET Package Is Trustworthy
Christopher D. Cavell · August 23, 2026
A practical guide to tracing a NuGet package from reviewed source through build, publication, and verifiable release evidence.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/ci-badge-does-not-prove-package-integrity.html
Your Authorization Check Runs Too Late
Christopher D. Cavell · August 23, 2026
Authorization can succeed while resource-state or workflow rules still block execution; resolve that decision before protected side effects begin.
Permanent URL: https://asibackbone.github.io/Learning/articles/2026/authorization-check-runs-too-late.html
Articles and Tutorials Serve Different Jobs
| Tutorial | Article |
|---|---|
| Part of a learning progression | Standalone technical argument |
| May have prerequisites | No curriculum prerequisite |
| Teaches a concept systematically | Makes one useful argument completely |
| May move as the curriculum evolves | Keeps a permanent publication URL |
Articles may link to tutorials, samples, labs, ADRs, or implementation repositories for deeper study, but those materials are optional follow-up rather than prerequisites.
Contribute an Article
Want to contribute an article? See the article publishing guidance.