Break Into AI Testing

Theme: Understand what we are building and testing.

Introduction: Students begin with cohort expectations, final portfolio outcomes, and the transition from foundational AI testing into advanced AI quality engineering.

Theory: Overview of the Build → Evaluate → Audit framework. Students review the architecture of the prebuilt AI system and learn where AI failures can happen across the full application flow.

System Walkthrough: Students explore the frontend, backend/API, LLM provider, system prompt, RAG layer, tool-calling/MCP concept, logging, evaluation folder, and deployment path.

Hands-on: Students clone or access the prebuilt app repository, review the folder structure, inspect key files, review environment variables, and map the flow from UI → API → LLM → response.

End-of-Day Deliverable: AI System Architecture Notes + Initial Risk Areas.

Theme: Build enough to understand the system.

Tool Introduction: Students use Claude Code, Cursor, or another AI-assisted coding tool to understand the application codebase.

Hands-on: Students run the app locally, troubleshoot setup issues, and use an AI coding assistant to explain API routes, prompt flow, RAG flow, tool-calling flow, and error handling.

Practical Extension: Each student chooses one small improvement or change to the application, such as adding a new system prompt version, adding a policy document, improving logging, creating a new API route, or adding a debug/test mode.

End-of-Day Deliverable: Local Running App + Small Feature Extension + Architecture Map.

Theme: Move from localhost to a live system.

Theory: Students learn why deployed AI systems create new quality, security, and reliability risks. The session covers deployment architecture, environment separation, secrets, API keys, and common deployment issues.

Deployment Preparation: Students prepare a deployment checklist and review risks such as CORS errors, missing API keys, broken routes, timeout errors, rate limits, and environment mismatch.

Hands-on: Students prepare the app for deployment, configure environment variables, create or validate a health check endpoint or smoke test route, push changes to GitHub, and begin the deployment process.

Suggested Tools: Vercel, Render, Railway, Supabase, hosted vector database, or simple starter storage option.

End-of-Day Deliverable: Deployment Readiness Checklist + GitHub Repo Prepared.

Theme: Deploy the system and validate it externally.

Deployment: Students deploy the prebuilt app together with their own extension and validate the public app URL.

Testing: Students test the live UI, exposed API endpoint, secrets handling, basic error scenarios, and deployment evidence.

Hands-on: Students run a live chat request, ask a RAG-based question, trigger a tool/MCP-related request, send invalid and empty requests, test long prompts, run a basic prompt injection attempt, and validate the API response structure.

End-of-Day Deliverable: Live App URL + Exposed API Endpoint + Smoke Test Evidence.

Theme: Test actions, not just answers.

Theory: Students learn how modern AI systems connect with tools and context through MCP, function calling, and API-based tool use.

Advanced Testing: The session covers tool misuse risks, permission boundary testing, tool input/output validation, and how tool calling changes the QA strategy.

Hands-on: Students test correct and incorrect tool selection, unauthorized tool requests, manipulated tool parameters, tool failure handling, tool output hallucination, missing confirmation before risky actions, and multi-step workflow failures.

Example Test Scenarios: Create support ticket, search internal policy, retrieve customer profile, summarize account history, and escalate to human review.

End-of-Day Deliverable: MCP / Tool-Calling Evaluation Report.

Theme: Evaluate whether the AI system answers from the right source.

Theory: Students review RAG testing concepts, retrieval failures vs. generation failures, chunking, embeddings, source quality, groundedness, faithfulness, and citation accuracy.

Testing Strategy: Students learn how to create test cases from source documents and how to detect missing-answer failures, conflicting information, hallucination traps, unsupported claims, bad citations, and prompt injection inside documents.

Hands-on: Students build RAG evaluation test cases, test out-of-scope questions, test partial retrieval behavior, and evaluate whether the model is answering from the correct source of truth.

Suggested Tools: Promptfoo or Agenta, manual test sheet, source-of-truth document, live app API.

End-of-Day Deliverable: RAG Evaluation Test Set + Groundedness Findings.

Theme: Find failures before users or attackers do.

Theory: Students review AI red teaming fundamentals, OWASP LLM and agentic AI risks, prompt injection, jailbreak attempts, unsafe tool usage, memory/context manipulation, policy bypass, access-control issues, and cascading failure scenarios.

Hands-on: Students run direct prompt injection attempts, indirect prompt injection through retrieved content, role manipulation, system prompt extraction, tool misuse attempts, unauthorized data access attempts, business rule bypass tests, and multi-turn attacks.

End-of-Day Deliverable: Red Team Findings Log + Initial Risk Classification.

Theme: Use traces and monitoring as testing evidence.

Theory: Students learn AI observability concepts and why traces, logs, metrics, scores, latency, cost, token usage, retrieved context, tool calls, errors, session IDs, and evaluation scores matter for quality engineering and audit evidence.

Tool Exposure: Students review Langfuse, Arato-style observability, application logs, and evaluation outputs from Promptfoo or Agenta.

Hands-on: Students capture and review traces for successful responses, hallucinated responses, failed tool calls, RAG retrieval issues, prompt injection attempts, slow responses, and API errors.

End-of-Day Deliverable: Observability Evidence Pack + Monitoring Findings.

Theme: Communicate like an AI Quality Engineer.

Final Optimization: Students finalize their audit report, prepare their portfolio presentation, and practice explaining technical findings to non-technical stakeholders.

Career Preparation: Students learn how to discuss the project in interviews and position their work on LinkedIn, resumes, and professional portfolios.

Hands-on: Students present the system they tested, explain what they built or extended, summarize what they evaluated, share the most important risks they found, show what observability revealed, recommend controls, make a release readiness decision, and reflect on key lessons learned.

End-of-Day Deliverable: Final AI Quality Audit Portfolio.

Theme: Turn test results into risk-based audit evidence.

Theory: Students learn the difference between a bug, defect, risk, and control. The session introduces OWASP/AIVSS-style risk thinking and explains how agentic AI systems can amplify risk.

Audit Preparation: Students map findings to categories such as tool misuse, access control, RAG hallucination, prompt injection, memory/context manipulation, untraceable decisions, poor observability, and unsafe deployment behavior.

Hands-on: Students build a risk register, assign severity ratings, link screenshots, traces, logs, or reports as evidence, recommend controls, and make a release readiness decision.

End-of-Day Deliverable: AI Risk Register + Draft Audit Report.