Learn AI, from zero to production.

Models generate text, images, audio, or code from learned patterns. A convincing answer can still be wrong.

Use them to propose, transform, summarize, or explore. Keep human decisions where errors can affect people, money, rights, or safety.

Chat answers; search locates; RAG supplies documents; automation follows defined steps; an agent chooses which tool to use.

Start with the least autonomous mechanism that solves the problem. Add memory, tools, or loops only when you can prove the need.

Separate facts, inferences, and recommendations. For each important fact, request a source and verify that it truly supports the claim.

When evidence is insufficient, the correct behavior is to abstain or state uncertainty.

A chat organizes messages and may add files, search, or memory. The model only computes a response from the effective input of that call; it does not remember all your conversations by itself.

The context window has a limit. As instructions, documents, and replies accumulate, the application must trim, summarize, or retrieve only what matters. Every strategy can lose information.

Always check which information is sent, what persists outside the model, and which part comes from a connected tool.

A good brief describes the observable result, allowed data, forbidden behavior, and how it will be checked.

Ask for a plan or small sample first when the work is costly or hard to reverse.

Request graded explanations, examples, and questions. Then close the chat and reconstruct the idea in your own words.

Disclose AI use when your institution requires it, and never fabricate sources, data, or experiments.

Do not enter secrets, medical records, case files, credentials, or third-party data without a lawful basis, authorization, and proper controls.

Replace real data with fictional examples and share only the fragment needed for the task.

Guessing whether text was generated does not show what a learner understood. Design submissions that preserve decisions, sources, drafts, and changes.

Combine an AI-assisted phase with a short unaided explanation, an oral defense, or application to a new case.

The policy should explain permitted uses, required disclosure, and which evidence must belong to the learner.

Check columns, types, units, nulls, duplicates, and dates before asking for conclusions. AI does not silently repair a broken dataset.

Every transformation must be reproducible and reviewable.

RAG splits documents, builds representations for retrieval, and supplies relevant passages to the model. It does not turn incorrect documents into truth.

A citation should locate the document and passage supporting the answer.

Record whether the correct passage appeared, whether the answer used it, whether citations were correct, and whether it abstained when required.

Do not improve the prompt to hide a retriever that returns the wrong documents.

Give the model the necessary schema, not unnecessary private rows. Request both a query and an explanation of the fields used.

The controller should initially allow only SELECT, validate tables and columns, impose a row limit, and block extensions or file-path access.

A numerical answer is reproducible when it preserves the question, SQL, dataset version, and result returned by the engine.

Define who uses the product, which problem it solves, which data it touches, and which states it must show. Include loading, empty, error, and success.

Build one small end-to-end path first; expand after testing it.

Start read-only. Ask the agent to identify files, constraints, and tests before editing.

Review the diff, run checks proportional to risk, and keep a rollback path.

A website is not finished when it compiles. Check navigation, contrast, forms, metadata, secrets, domain, and recovery from a bad deployment.

Keep preview and production separate, and document external variables and costs.

Before editing, check the branch, repository status, and project instructions. Then review only the files related to the goal.

The diff should communicate intent: avoid mixing formatting, refactors, and new behavior unless they must travel together.

A passing test does not replace reading the change. Review side effects, data, permissions, and rollback before integration.

Compare models on your own cases. Review license, languages, context, memory requirements, and published limits.

Open weights does not necessarily mean open source or unlimited permission for every use.

Ollama simplifies local execution, but the model still consumes storage, RAM, or VRAM. Do not expose the service to the Internet without authentication and controls.

Record version, exact model, quantization, and hardware so the test is reproducible.

Local can reduce data egress and variable cost, but adds hardware and maintenance. An API can offer greater capability, but introduces dependency, external processing, and usage cost.

A hybrid design uses policy to decide which tasks and data may use each route.

Model weights, quantization, context cache, and other processes compete for memory. A model loading does not mean it responds at the latency you need.

NVIDIA, AMD, and Apple Silicon have different acceleration and compatibility paths. Verify the exact tool, operating system, and model in official sources.

Test with your prompts and measure peak memory, time to first token, and sustained speed. Include the worst context you will actually use.

Document inputs, decisions, outputs, owners, and failures. If people do not agree on the process, an agent will only automate confusion.

Separate proposal, approval, and execution when an action can cause harm.

MCP standardizes how an application exposes resources and tools to a model. It does not make an unsafe tool safe.

Limit scope, validate arguments, log calls, and require approval for writes, payments, publishing, or deletion.

Agents fail because of networks, limits, processes, or invalid responses. Store each transition and separate attempt, approval, and execution.

Use idempotency keys, retry limits, and a review queue for ambiguous cases.

A model call generates from supplied context. A tool executes a bounded function. MCP standardizes how that capability is discovered and invoked. RAG retrieves evidence. An agent can choose the next step.

Build all five steps with the same case so the comparison remains valid. Keep code in control of permissions, steps, citations, and stopping.

Do not add a loop when a deterministic workflow solves the problem. Every step must justify its new capability and new risk.

Evaluate quality before deployment and monitor failures afterward. Retain minimized input, version, tools, latency, cost, and outcome where appropriate.

Logs are sensitive data too: apply access control, retention, and redaction.

Define who responds, which alerts matter, how credentials are revoked, how a backup is restored, and how the service continues without AI.

Test prompt injection, malicious data, tool abuse, and provider dependency.

Choose a real, narrow problem. Document user, data, minimum architecture, risks, tests, cost, deployment, maintenance, and limits.

The project is complete when another person can run it, verify it, and understand when not to use it.

Red teaming is not about collecting jailbreaks. Start from the threat model and cover privacy, secrets, instructions in documents, tool abuse, consumption, and harms relevant to the use case.

Run tests only in an authorized environment, with fictional data and no impact on third parties. Record input, configuration, output, severity, and reproducibility.

A mitigation should become code, permissions, filtering, evaluation, or human process and prove it does not break legitimate cases.