By the end of today,
you'll have shipped
two AI apps.

We climb gently — a "wow" at every step, then we build. Timings are a guide; the ★ moment is when you ship.

AI is not new — it's 70 years old. So why did it explode in your feed only recently? Two things changed, and they changed everything about what you can build.

The two big shifts

LLM = Large Language Model. Strip the hype and it does exactly one thing, unbelievably well: it predicts the next chunk of text. Everything — chat, code, summaries — is built on that single trick.

First: words become tokens

A model doesn't read letters or words — it reads tokens (pieces roughly ¾ of a word). It thinks in tokens and you pay per token, so let's see them. Type anything:

Then: it predicts the next token — over and over

Given the tokens so far, the model scores every possible next token with a probability, picks one, adds it, and repeats. That loop is "generating text".

One more truth: the model has no memory

Between calls, an LLM forgets everything. Anything it should "know" in a conversation must be re-sent every time, inside a limited context window (measured in tokens). This one fact quietly explains a huge amount of AI engineering.

Here's the part that makes people go "ohhh". How do you teach a machine language without an army of humans labelling billions of examples? You let it play fill-in-the-blank with the entire internet.

Try being the model for a second — guess the hidden word:

First, a quick upgrade to your mental model. Modern AI isn't just about text anymore — it can also see, hear and speak. We call these foundation models: one giant general-purpose brain you adapt to many jobs.

Multimodal: models with more senses

Show it a photo of your fridge → get a recipe. Speak to it → it talks back. Same idea as text, more senses.

The 8 things people build with AI

Almost every AI product you've seen falls into one of these buckets. Find your idea here:

Today we build a 📥 Info-Aggregation tool — an AI Website Summarizer. Simple, genuinely useful, and very shareable.

One line: AI Engineering is building real products on top of pre-trained models (GPT, Claude, Gemini) — without training those models yourself.

Three roles, cleanly separated

Step 0 — Get set up (do this once, ~10 min)

Before any code runs, three quick bits of plumbing. Don't worry — it's a one-time setup.

① Install a code editor — Cursor or VS Code

You need one editor to write and run code. Both are free and work identically for this course — pick whichever you like:

② Get your OpenAI API key

An API key is a secret password that lets your code use OpenAI's models (you pay only for what you use — cents for this class). Here's the flow, simulated — click through it:

③ Put the key in a .env file (never in your code)

Create a file literally named .env in your project folder, and paste your key inside. Your code reads it from there — so the secret never appears in the code you share.

# .env  — keep this file private! Add it to .gitignore
OPENAI_API_KEY=sk-proj-xxxxxxxxxxxxxxxxxxxxxxxx

# pip install python-dotenv
from dotenv import load_dotenv
load_dotenv()                 # loads everything from .env

# now OpenAI() finds the key automatically — no key in your code 🎉

Now — the 6 lines that actually talk to the AI

With setup done, calling an LLM is just an API call — like fetching the weather, except the reply is intelligence. Here's the whole thing:

# pip install python-dotenv
from dotenv import load_dotenv
# pip install openai
from openai import OpenAI
load_dotenv()                 # loads everything from .env

client = OpenAI()   # reads your API key from the environment

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "You are a witty travel guide."},
        {"role": "user",   "content": "Suggest one thing to do in Bangalore."},
    ],
)
print(response.choices[0].message.content)


# now OpenAI() finds the key automatically — no key in your code 🎉

The 3 "roles" — the entire grammar of chat models

Bonus: the same code on a free, blazing-fast model (Groq + Llama)

Don't want to add billing yet? Groq gives you a free API key and runs open models like Meta's Llama incredibly fast. Because Groq speaks the same "language" as OpenAI, you change just two things — the key and one line — and everything else stays identical:

# pip install openai   (yes — the same library!)
import os
from openai import OpenAI
from dotenv import load_dotenv
load_dotenv()

# point the SAME client at Groq instead of OpenAI 👇
client = OpenAI(
    api_key=os.getenv("GROQ_API_KEY"),
    base_url="https://api.groq.com/openai/v1",
)

response = client.chat.completions.create(
    model="llama-3.3-70b-versatile",        # a free Llama model on Groq
    messages=[
        {"role": "system", "content": "You are a witty travel guide."},
        {"role": "user",   "content": "Suggest one thing to do in Bangalore."},
    ],
)
print(response.choices[0].message.content)

Time to build. Our app: give it any web page URL → it reads the page and hands you a clean summary. The Reader's Digest of the internet. It's simple, genuinely useful, and exactly the kind of thing that makes a great first LinkedIn post.

How it works — the whole app in one picture

Five boxes. That's a real AI product. Let's write each piece.

Step 1 — Grab the page text (the "scraper")

# pip install requests beautifulsoup4
import requests
from bs4 import BeautifulSoup

HEADERS = {
    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
                  "AppleWebKit/537.36 (KHTML, like Gecko) "
                  "Chrome/120.0 Safari/537.36",
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
    "Accept-Language": "en-US,en;q=0.9",
}

def fetch_website_contents(url):
    # add scheme if the user forgot it
    if not url.startswith(("http://", "https://")):
        url = "https://" + url

    try:
        response = requests.get(url, headers=HEADERS, timeout=15)
        response.raise_for_status()
    except requests.exceptions.RequestException as e:
        return f"Could not fetch the website. Error: {e}"

    soup = BeautifulSoup(response.text, "html.parser")
    title = soup.title.string if soup.title else "No title found"

    for tag in soup(["script", "style", "nav", "footer", "header", "img", "input"]):
        tag.decompose()

    text = soup.get_text(separator="\n", strip=True)
    return f"Title: {title}\n\nPage contents:\n{text}"

Step 2 — The brain (prompt + LLM call)

from openai import OpenAI
from dotenv import load_dotenv
from scraper import fetch_website_contents

load_dotenv()          # <-- this reads your .env file
client = OpenAI()

system_prompt = """You analyze the contents of a website and
give a short, friendly summary. Ignore navigation menus.
Respond in markdown."""

def summarize(url):
    website = fetch_website_contents(url)
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role":"system", "content": system_prompt},
            {"role":"user",   "content": f"Summarize this website:\n\n{website}"},
        ],
    )
    return response.choices[0].message.content

Step 3 — The face (Gradio = a web app in 4 lines)

Nobody will run your Python script. Gradio turns your function into a shareable web app — no HTML, no CSS, no JavaScript:

# pip install gradio
import gradio as gr
from summarizer import summarize

gr.Interface(
    fn=summarize,                                  # your function
    inputs=gr.Textbox(label="Website URL"),
    outputs=gr.Markdown(label="Summary"),
    title="🔎 AI Website Summarizer",
).launch(share=True)   # share=True → a public link you can post! 🎉

Step 4 — Run it on your machine 👇

Save the three files (scraper.py, summarizer.py, app.py) and your .env in one folder. Then open the terminal in Cursor (Terminal → New Terminal) and run:

# 1. install everything you need (one time)
$ pip install openai gradio requests beautifulsoup4 python-dotenv

# 2. launch the app
$ python app.py

# 3. Gradio prints two links:
Running on local URL:  http://127.0.0.1:7860
Running on public URL: https://a1b2c3.gradio.live   # ← share this!

🐞 If you hit an error, 90% of the time it's a missing pip install or a key not loaded from .env — check those two first.

Try the working version right here

Below is a live, in-browser version of exactly that app. Pick a sample site (or paste your own text), choose a personality, and hit summarize:

⚙️ This demo summarizes in your browser (a simple method) so it runs with no API key. Your real app.py sends the text to GPT for a smarter summary — but the shape, the flow, and the personality switch are exactly what you see here.

🥊 Bonus build: an LLM Arena (one prompt, two models, you judge)

Here's a second mini-project that's even more fun to post. Inspired by arena.ai, where people send one prompt to two AIs and vote on the better answer — that's literally how the world ranks AI models. You can build a tiny version with what you already know: send the same prompt to two models, show both answers side by side.

def battle(prompt):
    msgs = [{"role": "user", "content": prompt}]

    # Model A — OpenAI's GPT
    a = openai_client.chat.completions.create(model="gpt-4o-mini", messages=msgs)

    # Model B — Llama on Groq (same code, different brain!)
    b = groq_client.chat.completions.create(model="llama-3.3-70b-versatile", messages=msgs)

    return a.choices[0].message.content, b.choices[0].message.content
# …now we wrap this in Gradio with two columns + thumbs up/down 👇

The full Gradio app (with 👍 / 👎 voting, like arena)

# pip install openai gradio python-dotenv
import os
import gradio as gr
from openai import OpenAI
from dotenv import load_dotenv
load_dotenv()

openai_client = OpenAI()                                  # uses OPENAI_API_KEY
groq_client   = OpenAI(api_key=os.getenv("GROQ_API_KEY"),
                            base_url="https://api.groq.com/openai/v1")

def ask(client, model, prompt):
    r = client.chat.completions.create(
        model=model, messages=[{"role": "user", "content": prompt}])
    return r.choices[0].message.content

def battle(prompt):
    a = ask(openai_client, "gpt-4o-mini", prompt)
    b = ask(groq_client, "llama-3.3-70b-versatile", prompt)
    return a, b

def vote(label):
    return f"🗳️ Thanks! You voted: **{label}**"   # in real apps, save this to a file/DB

with gr.Blocks(title="LLM Arena") as demo:
    gr.Markdown("# 🥊 LLM Arena — one prompt, two models")
    prompt = gr.Textbox(label="Ask both models the same thing")
    go = gr.Button("⚔️ Battle!", variant="primary")

    with gr.Row():
        with gr.Column():
            gr.Markdown("### 🤖 Model A")
            out_a = gr.Markdown()
            with gr.Row():
                up_a   = gr.Button("👍");  down_a = gr.Button("👎")
        with gr.Column():
            gr.Markdown("### 🤖 Model B")
            out_b = gr.Markdown()
            with gr.Row():
                up_b   = gr.Button("👍");  down_b = gr.Button("👎")

    verdict = gr.Markdown()

    go.click(battle, inputs=prompt, outputs=[out_a, out_b])
    up_a.click(lambda: vote("👍 Model A"), outputs=verdict)
    down_a.click(lambda: vote("👎 Model A"), outputs=verdict)
    up_b.click(lambda: vote("👍 Model B"), outputs=verdict)
    down_b.click(lambda: vote("👎 Model B"), outputs=verdict)

demo.launch(share=True)   # → local + public link 🎉

Run it (same as before)

# install once, then launch
$ pip install openai gradio python-dotenv
$ python arena_app.py

Running on local URL:  http://127.0.0.1:7860
Running on public URL: https://abcd12.gradio.live   # ← share this on LinkedIn!

⚙️ Responses here are simulated in your browser so it runs key-free. In your real arena.py, the two answers come from the actual models — and the voting is exactly how arena.ai builds its public leaderboard.

A project nobody sees doesn't build your name. The single highest-leverage thing you can do as a beginner is build small & share loudly. Let's get your summarizer out the door.

The 3-step ship checklist

Steal this caption (fill in the blanks)

👉 When you type "@Shivank Agrawal", LinkedIn will suggest the profile — pick linkedin.com/in/shivankagrawal so the tag links correctly. Tagging your instructor & Scaler boosts reach and lets us reshare your win.

Want a different flavour? Make it yours

Same 3-step recipe (input → prompt → Gradio), different idea. Pick whichever feels fun — all are beginner-simple:

💡 These are drawn from real beginner projects in your course's community folder — proof that "simple + shipped" beats "complex + someday".

You've built an app that answers. The rest of this journey is about apps that do. Here's a taste of three things coming up — no need to master them today, just get excited.

🔗 LangChain — the toolkit for bigger apps

Right now you call the API by hand. The moment you want reusable prompts, multi-step pipelines, memory, or to plug in your own documents, a framework like LangChain saves you re-inventing the wheel. Same idea as today — just with handy connectors:

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_template("Summarize this website: {content}")
model  = ChatOpenAI(model="gpt-4o-mini")

chain = prompt | model            # "|" = send the prompt INTO the model
chain.invoke({"content": website_text})   # reuse it for any page!

🤖 Agents — when the AI can take action

An agent is an LLM given tools (a calculator, web search, your database) and a loop: it thinks, acts, looks at the result, and repeats until done. Step through one:

👥 Multi-Agent — a team of AIs

For bigger jobs, we do what companies do: split work across specialists that hand off to each other. Press run and watch a content team write a LinkedIn post: