AI Testing with Python —
From Your First ML Model to Self-Healing Frameworks

Move from building a tiny model to commanding a state-of-the-art LLM. You get a free Gemini API key, learn the 7-element prompt structure that makes the difference between mediocre and great output, and build a chatbot that remembers context.

• Sign up to Google AI Studio (aistudio.google.com), generate a Gemini API key
• Install the official SDK: pip install google-genai
• The 7-element prompt framework: role · task · context · tone · format · constraints · question
• Single-turn requests: genai.GenerativeModel(...).generate_content(prompt)
• Stateful chatbot: model.start_chat(history=[]), chat.send_message() — preserves conversation context
• System instructions: keep the model on-topic across a long session
• Trade-offs of cloud LLMs: cost · security / data leakage · internet dependence · version drift
• Why this matters: every other module in the course leans on prompts you write yourself

Cloud LLMs are great until cost, latency or data privacy stops you. Ollama lets you run a capable LLM entirely on your own laptop — no internet required, no tokens billed, no data leaving the machine. You'll use a 1.5 B model that's small enough to run anywhere.

• Install Ollama; verify it's running at http://localhost:11434
• Pull a model: ollama pull qwen2.5-coder:1.5b
• List, run and chat: ollama list · ollama run qwen2.5-coder:1.5b
• The 3 message roles every chat API uses: user · system · assistant
• Call Ollama from Python with the requests library — same pattern you'll reuse for any LLM
• Install Open WebUI for a ChatGPT-style local interface: pip install open-webui
• When to choose local over cloud: data sensitivity, predictable latency, zero per-call cost

An LLM only knows what it was trained on. RAG (Retrieval-Augmented Generation) plugs in live information so the model can answer today's questions, not last year's. You'll build two RAG pipelines — one with a free search engine, one with Google's — and then automate Gmail-sending from Python.

• What RAG actually means: Retrieval (fetch fresh data) · Augmented (merge with prompt) · Generation (LLM answers with context)
• Free pipeline: DuckDuckGo (pip install ddgs) feeds search results to local qwen2
• Paid pipeline: SerpAPI (pip install google-search-results) feeds Google results to Gemini
• Sign up at serpapi.com, copy API key, hit the same Google index Google itself uses
• Send Gmail from Python: enable 2-factor auth, generate an App Password at myaccount.google.com/apppasswords
• SMTP send pattern using stdlib — no third-party email service required
• When to choose which: DDG/Ollama for cost · SerpAPI/Gemini for quality and structured results

Two ways to build the same agent. First the Python version: read a question from Excel, ask AI, reply by email. Then the visual version on make.com: same agent in 15 minutes with zero custom code. You'll know when to reach for which.

• Python AI Agent: read questions from Excel with openpyxl, compose AI reply, send email
• Google Forms → Google Sheets: collect responses without writing a backend
• Publish a Sheet as a public CSV URL — instant data feed for any pipeline
• make.com scenarios: visual node editor for workflow automation
• "Watch new rows" Google Sheets trigger — fires automatically on new submissions
• Make AI module: drop-in LLM step inside the scenario
• Gmail action: send formatted reply email back to the user
• Decision rule: Python when you need control and integration; make.com when you need speed and zero ops

Connect everything from the previous modules into one self-running pipeline: push code → GitHub Actions runs the framework → Allure report deploys to GitHub Pages → an AI summarises results → email lands in your inbox. You leave this module with a workflow you can drop into any client repo on Monday.

• Trigger on push: when code lands on master, GitHub Actions kicks off a full test run
• Ubuntu runner setup: install Python · Java · Allure CLI · pytest · Playwright · browsers
• Run tests with --alluredir=allure-results --junitxml=junit.xml
• Generate Allure HTML report from results
• Deploy report to GitHub Pages via peaceiris/actions-gh-pages
• Parse junit.xml inline (Python heredoc) for total / passed / failed / skipped counts
• POST JSON payload to a make.com webhook URL stored in MAKE_WEBHOOK_URL secret
• make.com receives the payload, feeds it to "You are a Senior QA Automation Lead" prompt, sends email
• Upload videos/ artifact so failures are debuggable later

Manual testing is not going away — but it is changing. This module shows the manual-tester end of the pipeline: feed a requirements doc to an LLM and generate scenarios, steps, data and defect reports. You also learn the two parameters (temperature, top_p) that decide whether AI sounds robotic or unpredictable, and how to spot when it's hallucinating.

• Temperature (0 = robotic / 0.3 = controlled / 0.8 = creative / 1.0 = unpredictable)
• top_p: word-probability cutoff — pairs with temperature to shape output
• Why markdown beats .doc / .pdf / .xlsx as AI input
• Convert .docx requirements to .md with pypandoc + pandoc binary
• Prompts to generate: test scenarios · test steps · test data · review comments · defect reports
• Realistic vs scale-generated test data — when to write each by hand
• AI Bias — Representation Bias from skewed training data
• Hallucination — AI confidently producing data that doesn't exist
• QA habits to catch bad output before it ships

Where AI changes test-automation writing the most. You'll use GitHub Copilot for vibe coding inside PyCharm, swap it for a free local LLM via the Continue plugin and Ollama, then connect Microsoft's Playwright MCP so an AI agent can drive a real browser as it generates the script.

• Vibe coding: describe what you want in plain English, AI writes the code
• PyCharm setup: enable Code Completion, install GitHub Copilot plugin
• The 6 daily uses: write · explain · refactor · debug · MTC → automation · code migration (Selenium ↔ Playwright)
• Convert JS Playwright to Python Playwright (or the reverse) with one prompt
• Use a local LLM inside the IDE — install Continue plugin, point it at localhost:11434
• MCP — Model Context Protocol: standardised way AI tools talk to applications
• Install Microsoft's Playwright MCP: requires Node.js → npm install @playwright/mcp@latest
• Wire up mcp.json in PyCharm; enable MCP Server in settings
• Use Copilot in Agent mode + Playwright MCP: AI opens a real browser, finds locators, writes verified script

The final module is the headline result of the course. You install Antigravity (Google's agentic IDE), describe the framework you want in English, watch it generate a working pytest + Playwright + Page Object framework, then upgrade it with an AI-healing mechanism that auto-fixes broken locators — caching the fixes so you only pay the AI tax once per locator.

• Agentic AI: AI manager → AI tools → real-world actions (the conceptual map)
• Install Antigravity from antigravity.google/, sign in with Gmail
• Generate a Python Playwright + pytest framework via prompt: BaseTest, page objects, sample test
• Approve plan → Antigravity writes the files → run the sample test → it just works
• Convert an Excel manual test case (OSPOS) to an automated Page Object Model script via prompt
• Configure config.properties + framework conventions so AI follows your structure
• Add an AI-based self-healing locator mechanism using Gemini:
• Try original locator → on failure, call Gemini for a new working locator → use it
• Log both attempts; expose a single utility findElementWithHealing(page, locator)
• Cache healed locators in locator_db.json — try original → check DB → call AI only on cache miss
• Result: the locator-breaking UI change that used to kill your suite is now a logged warning