math,random,
datetime)
- Handling Errors Gracefully
- What an exception is and why
programs raise them
- Basictry /
except to handle errors
- Reading an error message to
understand what went wrong
- Reading and Understanding Code
- Following the flow of an existing
Python script
- Recognizing the building blocks
learned so far in real code
- Knowing enough to direct, review,
and correct generated code
- Libraries & Environments at a Glance
- Installing packages with
pip and what a library provides
- The idea of a virtual environment
and why projects stay isolated
- Where code lives in a project and
how files connect
- Coding with AI Assistants
- Using GitHub Copilot for inline
suggestions in VS Code
- Driving changes with Claude Code
from the terminal
- The course philosophy: you
understand how the language works, AI writes the code, and you
direct and review it
- The Model's View of Text
- Tokens and tokenization — why
characters, words, and tokens differ
- Context windows, input/output
limits,
and what gets truncated
- The autoregressive next-token loop
in
plain terms
- Sampling and Determinism
- Temperature, top-p, and their
effect on
output variability
- When to favor deterministic vs.
exploratory generation
- System, user, and assistant roles
in a
chat transcript
-
Capabilities and Limits
- Knowledge cutoffs, hallucination,
and
where models fail
- Comparing responses across ChatGPT,
Claude, and Gemini
- Reading model documentation to
choose
the right model
- Anatomy of Good Context
- The four building blocks: role,
task, examples, output format
- Few-shot examples and how they
steer behavior
- Constraining responses to JSON and
other parseable formats
- Reusable Prompt Patterns
- Zero-shot, few-shot,
chain-of-thought, and decomposition patterns
- Templating prompts with variable
slots for reuse
- Iterating systematically and
measuring quality changes
- Versioning Context in Git
- Storing prompts as files alongside
code
- Tracking prompt revisions with
commits and diffs
- A/B comparing prompt versions
across multiple models
- Mapping the Landscape
- Foundation models, hosted APIs, and
open-source weights
- Proprietary vs. open models and the
trade-offs of each
- How providers differ on context
size, speed, and pricing
- Getting the Most from Chat Interfaces
- Advanced use of ChatGPT, Claude,
and Gemini for real tasks
- Custom instructions, projects, and
conversation memory
- File uploads, document analysis,
and long-context workflows
- Practical Model Selection
- Matching task type to model
strengths
- Cost, latency, and quality as
selection criteria
- Building a personal benchmark
across the three tools
- Beyond Text
- Image, audio, and document inputs
to multimodal models
- Vision tasks: description,
extraction, and reasoning over images
- Combining modalities in a single
prompt
- Image Generation
- Generating images and iterating on
prompts for control
- Style, composition, and
reference-guided generation
- Practical limits, artifacts, and
content constraints
- Comparative Workflows
- Running the same multimodal task
across ChatGPT, Claude, and Gemini
- Evaluating output fidelity and
consistency
- Choosing a tool per use case based
on results
- First API Calls
- Authentication, API keys, and
storing secrets safely
- Making completion requests to the
OpenAI, Claude, and Gemini APIs
- Inspecting responses, token usage,
and finish reasons
- Structured Outputs
- Defining schemas with Pydantic
models
- Forcing valid JSON output and
validating it on return
- Handling parsing failures and
retries
- Streaming and Responsiveness
- Consuming streamed token responses
- Rendering partial output for better
UX
- Cancelling and timing out long
generations
- Function Calling and Tools
- Exposing functions to a model as
callable tools
- Parsing tool-call requests and
returning results
- Building a simple tool-using loop
- Composing Multi-Step Workflows
- Prompt chains: feeding one model
output into the next
- Orchestrating chains, memory, and
tools with LangChain
- Structuring agents that decide
which step to run
- Operating in Production
- Rate limits, backoff, and retry
strategies
- Tracking and controlling token cost
across calls
- Logging, caching, and error
handling for reliability
- Loading and Inspecting Data
- Series and DataFrames; reading CSV,
JSON, and Excel
- First-look inspection: shape,
types, head/tail, and summary statistics
- Indexing and selection with `loc` /
`iloc`, filtering, and sorting
- Data Cleaning
- Handling missing values,
duplicates, and inconsistent entries
- Type coercion, parsing dates, and
normalizing text
- Detecting and treating outliers
- Transformation and Feature Work
- `groupby`, aggregation, joins, and
reshaping (pivot/melt)
- Deriving new columns, binning, and
encoding categories
- Vectorized operations with NumPy
under the hood
- Exploratory Data Analysis & Visualization
- Distributions, correlations, and
descriptive statistics
- Plotting with Matplotlib and
Seaborn: histograms, scatter, box, and line charts
- Telling a story from data and
working interactively in Jupyter
- The Modeling Workflow
- Framing classification and
regression problems
- Train/test splits, validation sets,
and cross-validation
- Fitting and predicting with
scikit-learn estimators
- Core Algorithms
- Linear and logistic regression
- Decision trees and ensemble methods
- Feature scaling, encoding, and
pipelines
- Honest Evaluation
- Accuracy, precision, recall, and F1
— and when each matters
- Confusion matrices and threshold
selection
- Diagnosing overfitting,
underfitting, and data leakage
- Neural Network Intuition
- Neurons, weights, biases, and
activation functions
- The forward pass, loss functions,
and what training optimizes
- Gradient descent and
backpropagation, conceptually
- A tiny PyTorch model: the training
loop in practice
- Embeddings as the Central Idea
- Representing words and items as
vectors
- Similarity, distance, and what
embedding space encodes
- Using embeddings for search,
clustering, and retrieval
- Transformers & Pretrained Models
- Self-attention and why it replaced
recurrence
- The transformer block and modern
architectures
- Loading and running pretrained
models from Hugging Face
- Fine-tuning vs. prompting vs.
retrieval
- Design Language
- Visual hierarchy, spacing,
alignment, and contrast
- Color systems, typography, and
consistency
- Design systems, components, and
design tokens
- UI/UX Concepts
- User flows, information
architecture, and navigation
- Usability principles and
accessibility basics
- Responsive design and common
interface patterns
- Frontend Basics
- How a web page is structured: HTML,
CSS, and components
- The role of layout, state, and
interactivity at a high level
- Reading and directing AI-generated
frontend code with intent
- Building the Frontend
- Generating interfaces with Lovable,
v0, and Cursor
- Turning a design intent into
working, responsive UI
- Iterating on layout, components,
and styling through AI
- Backend
- Building APIs with FastAPI and
connecting them to the UI
- Modeling data, authentication, and
core endpoints
- Databases
- Relational databases: Postgres,
Supabase, and SQLite for structured app data
- Document and NoSQL storage with
MongoDB for flexible, schema-light data
- Vector databases like Pinecone for
embeddings, semantic search, and RAG
- Choosing the right database for the
application's needs
- Deployment
- Connecting a GitHub repo for
serverless deployment on Vercel
- Environment variables, secrets, and
production configuration
- No-Code AI Agents
- Building automation workflows in
n8n
- Connecting services and triggers
with Make.com
- Wiring LLM calls into automated,
event-driven agents
- Deployment
- Containerizing services with Docker
where needed
- Connecting a GitHub repo for
serverless deployment on Vercel
- Environment variables, secrets, and
production configuration
- Capstone
- Architecting and building a
full-stack AI application end to end
- Producing a live URL, a complete
GitHub repository, and an architecture diagram
- Demoing the application and walking
through the build