Course Summary & Project Roadmap

Connecting the Full Generative AI Stack

A production Generative AI application is usually a stack rather than a single model. A common architecture is:

User → UI → Backend → Authentication → Prompt/Orchestration → Retrieval and/or Tools → Model → Output validation → UI → Monitoring

Each layer has a different responsibility. The UI handles interaction. The backend enforces business rules. Retrieval supplies external knowledge. Tools perform controlled operations. The model generates or reasons over the supplied information. Validation checks the result before it reaches the user.

The most important engineering lesson is to avoid asking the model to do everything. Deterministic software should handle deterministic tasks such as authentication, calculations, permissions and schema validation. The model should be used where language understanding, generation or flexible interpretation adds value.

RAG vs Fine-Tuning vs Prompting vs Agents

These four approaches solve different problems.

Prompting changes the instructions and context given to a model. It is usually the fastest starting point.

RAG supplies external information at inference time. It is useful when knowledge changes, belongs to an organization, or must be traceable to retrieved documents.

Fine-tuning adapts model behavior using examples. It is useful when a model needs a consistent style, task behavior or domain pattern that prompting alone does not reliably produce.

Agents add a control loop and tools so the system can decide which actions to take. Agents are useful when the task requires multiple steps or external operations.

A strong project often combines these: a well-designed prompt, retrieval for knowledge, a model adapted only if necessary, and limited tools for actions.

Evaluation of Generative AI Systems

Evaluation should be designed before the system is declared successful. Create a representative test set containing normal cases, edge cases, ambiguous cases and failure cases.

Measure the dimensions that matter: factual correctness, relevance, completeness, instruction following, structured-output validity, safety, latency and cost. For retrieval systems, also inspect whether the right passages were retrieved. For agents, inspect tool selection and whether the final action matched the user's goal.

Keep a regression set. Every important change should be tested against the same set so improvements can be distinguished from accidental changes.

Production Security Checklist

A practical security baseline includes secret management, authentication, authorization, input validation, output validation, rate limits, audit logs, safe tool permissions and clear data-retention rules.

Treat user-provided text, uploaded documents and retrieved web content as untrusted input. Do not allow retrieved content to silently override higher-priority system rules. Tool access should be limited to the minimum permissions needed for the task.

For sensitive workflows, add human approval before irreversible actions. Test prompt injection, data-exfiltration attempts, malicious documents and unexpected tool arguments as part of the normal security process.

Generative AI Project Roadmap

A strong student project can be built in stages:

Stage 1: Define one narrow problem and success metric. Stage 2: Build a basic working prototype. Stage 3: Add validation and error handling. Stage 4: Add retrieval, tools or structured outputs only when needed. Stage 5: Create an evaluation dataset and measure quality. Stage 6: Add authentication, security, monitoring and cost controls. Stage 7: Deploy and document limitations.

This approach prevents a common student mistake: building a visually impressive demo before proving that the underlying workflow is reliable.

Final Master Checklist

• [ ] Explain the difference between AI, ML, deep learning and Generative AI.

• [ ] Explain generative and discriminative approaches with examples.

• [ ] Describe neural-network training, loss, gradients and backpropagation.

• [ ] Explain CNN, RNN, LSTM and GRU at a conceptual level.

• [ ] Explain attention and the Transformer architecture.

• [ ] Explain tokenization and embeddings.

• [ ] Explain LLM pretraining, instruction tuning, preference training and inference.

• [ ] Use zero-shot, one-shot and few-shot prompting appropriately.

• [ ] Explain temperature, Top-K and Top-P.

• [ ] Identify hallucinations and design grounding or validation strategies.

• [ ] Explain autoencoders, VAEs, GANs and diffusion models.

• [ ] Describe image, audio and video generation workflows.

• [ ] Explain vector search and similarity metrics.

• [ ] Build and explain a RAG pipeline.

• [ ] Compare RAG, prompting, fine-tuning and agents.

• [ ] Explain LoRA, QLoRA and quantization.

• [ ] Explain tools, function calling, planning, memory and agent evaluation.

• [ ] Develop a basic Generative AI application with Python and APIs.

• [ ] Design security controls for prompt injection and data leakage.

• [ ] Explain deployment, monitoring, latency, scalability and cost.

• [ ] Defend a Generative AI project using measurable evaluation rather than a demo alone.