Learn the next thing — not everything.

A common table expression gives a complex statement a named, local step without creating a permanent table.

Window functions calculate rankings, running totals or previous values without collapsing the result into one row per group.

EXISTS expresses “at least one related row exists” and avoids accidental duplicate parent rows a join can introduce.

A SARGable predicate lets SQL Server use an index more effectively instead of applying a function to every candidate row.

The compiler language version controls syntax and features; the target framework controls the runtime and base libraries.

Records communicate value-like data and generated equality; classes usually communicate identity, lifecycle or mutable behavior.

Nullable reference types tell the compiler where null is expected; they improve feedback but do not add runtime validation.

Pass a CancellationToken from the request boundary into I/O operations so abandoned work can stop early.

An image packages filesystem layers and metadata; a container is an isolated process created from that image.

A multi-stage Dockerfile uses the SDK to publish, then copies only the published app into a smaller runtime image.

Build once and configure at runtime through environment variables, secret mounts or the platform secret store.

Compose gives a local .NET app a repeatable network, database, volume and health-check definition.

Track entities when you intend to modify them; use no-tracking queries for read-only projections.

Loading a related collection inside a loop can create one query per row; project or include deliberately instead.

A migration can lock tables, rewrite data or fail on existing values, so review it like application code.

A concurrency token lets EF Core detect that another writer changed a row since you read it.

A predictable status code and response shape help clients handle success, absence, validation and conflict without guessing.

Transport validation checks shape and basic rules; domain logic protects business invariants wherever the object is used.

Problem Details gives HTTP APIs a consistent error envelope without leaking stack traces or internal secrets.

A client may retry after a network failure even when the server already processed the command, so define an idempotency strategy.

A focused commit is easier to review, revert and move between branches than a mixed change.

Both integrate history; the important rule is whether you are rewriting commits other people already use.

Revert creates a new commit that undoes shared work; reset moves local branch pointers and can discard work.

Git bisect uses a known-good and known-bad commit to narrow a regression with logarithmic search.

An AWS design is incomplete until it says which identity can do what, to which resource and under which conditions.

A .NET application should read environment-specific settings at runtime and retrieve secrets from a managed mechanism.

The right AWS compute service depends on how much scheduling, patching, scaling and networking you want to own.

Logs, metrics and traces answer different questions; an incident needs all three connected by useful correlation context.

A Pod runs containers, a Deployment manages replica rollout and a Service gives clients a stable network identity.

Keep non-secret configuration and sensitive values separate, then inject them into the container at runtime.

Requests influence placement; limits cap usage. Both need values based on observation rather than copied defaults.

Readiness controls traffic, liveness detects a stuck process and startup probes protect slow-starting applications.

An AI request is a context assembled from instructions, conversation, tool results and user input; token limits constrain what the model can see and produce.

Capability, latency, cost, context, privacy and tool support are separate dimensions of a model decision.

If your application needs JSON, treat the model response as untrusted input and validate it before using it.

A model can propose a tool call, but your application must validate arguments, authorize the action, execute it and decide what result to reveal.

A useful AI feature needs observable success criteria, representative test cases and redacted traces—not only a thumbs-up demo.

A strong prompt states the role, task, input boundaries, output contract and what to do when information is missing.

Relevant context beats a large dump. Select files, examples and facts that change the answer, and label their trust and scope.

A small, representative example often communicates formatting and edge cases more reliably than several paragraphs of prose.

Prompt improvement works best when you compare versions against the same test set and change one meaningful variable at a time.

Prompt injection happens when untrusted content attempts to change the rules of the assistant or trigger an unsafe action.

Start with architecture, entry points, constraints and the specific files in scope before asking for implementation.

Examples and acceptance cases give the assistant an executable target and make generated code easier to review.

Small changes preserve reviewability, reduce accidental scope and make it easier to revert an AI mistake.

AI is most useful in debugging when you provide the exact symptom, reproduction, logs, expected behavior and what has already been tried.

Generated code needs a deliberate review for authorization, injection, secrets, dependency changes, data exposure and failure behavior.

Your application calls an endpoint; the gateway may route to a provider; the provider serves a model. Those layers can change independently.

9Router and OmniRoute are developer-facing local gateway projects: coding tools point at one local endpoint while the gateway handles provider integration, routing and fallback behavior.

Ollama is a local model runtime; hosted aggregators and gateways trade local control for access, convenience or provider breadth.

LiteLLM is useful to study as a team gateway pattern: one compatible API, model aliases, routing strategies, retries, budgets and provider configuration.

Fallback is not just “try another model”; it can change quality, context, tool support, privacy and cost.

A typical agent loop repeatedly selects context, asks the model for the next action, validates a tool call, executes it and checks whether the task is complete.

MCP standardizes a connection between an AI application and external data, prompts or tools; the host still controls the user experience and policy.

Tool schemas describe what a call looks like; authorization decides whether this caller can perform it on this resource now.

Conversation history, user preferences, retrieved documents and durable business state are different data categories with different retention rules.

An agent can produce a convincing final answer after taking the wrong actions, so evaluation must include tool selection, arguments, permissions, retries and side effects.

A beginner-friendly map of the system around a model: context, tools, permissions, execution, feedback and verification.

Keep provider-specific request code, credentials, timeouts and application behavior behind a small interface.

Send partial model output to the UI while keeping cancellation, buffering, errors and final usage explicit.

Use a schema and validation step when model output feeds code, a database, a workflow or a user-facing decision.

Treat a model tool call as a proposal that your application validates, authorizes, executes and reports back.

Turn text into vectors for approximate semantic retrieval, then combine similarity with metadata and normal application filters.

Ground a model answer in retrieved passages while preserving source identity, access control and a fallback for “not enough evidence”.