Roadmap

Where we're going today

• 1 · Prepare — GitHub Student Pack, VS Code, Copilot · at home
• 2 · Vibe coding — solve a real PS1 question with AI · in class
• 3 · Agents — build AI that uses tools & loops · in class
• 4 · Workshop — a research-assistant agent · at home

The tool under the hood

What is a large language model?

• A model trained on a huge slice of the internet — including billions of lines of public code.
• Its one job: given some text, predict the next word — over and over.
• No database lookup, no hidden reasoning engine. Just very, very good pattern completion.

Think “autocomplete that read the whole library,” not “a mind that knows facts.”

Why it works for us

Why it's so good at code

Read this twice

The catch: confident ≠ correct

• It predicts what's plausible, not what's verified true.
• It will invent functions that don't exist (“hallucinate”).
• It gets edge cases subtly wrong — and says it all with total confidence.

Your job: stay the engineer who decides what's actually correct.

What changes for you

The shift in your job

You're still the engineer — now the pilot, not the typist.

Warm-up ispow2(n)

Give the AI the constraints, not just the goal

# no bin / len / logs / strings — bit ops only. 0 is NOT a power of two.
def ispow2(n):
    return n > 0 and (n & (n - 1)) == 0

Tell it the forbidden built-ins up front — or it reaches for bin().

Demo longest_run(n)

Watch the loop on a real question

longest_run(n) → length of the longest run of consecutive 1 bits.

• Turn 1 — ask (it uses forbidden bin() 👀)
• Turn 2 — visualize the bits
• Turn 3 — write tests → green
• Turn 4 — catch the rule break → refactor → still green
• Turn 5 — push on edge cases & complexity

Before your turn

How to talk to the AI

• 🎯 Be specific — exact behavior, not vibes
• 🚧 State constraints — what's forbidden & required
• 🔢 Give examples — input → output pairs
• 🪜 Small steps — solve → test → edge cases
• 🕵️ Read every line — confident ≠ correct

The core idea

A single answer vs. an agent that acts

What is a tool?

A normal typed function the model can call

@agent.tool_plain
def word_count(text: str) -> int:
    """Return the number of words in the given text."""
    return len(text.split())

The docstring is the tool's instruction manual for the model.

Your stack = 3 choices

Framework · Model · Harness

Model & framework are easy swaps. The harness is what makes an agent good.

Architectures · first cut

Workflow vs. agent

Same brick underneath: the augmented LLM (model + tools + memory).

Architectures · the ladder simple → complex

Six patterns you compose

• 1 · Single agent — one loop + tools · start here
• 2 · Prompt chain — sub-agents in a fixed flow, A → B → C
• 3 · Routing — classify, hand off to the right specialist
• 4 · Parallelization — fan-out / fan-in (split, or vote)
• 5 · Orchestrator + specialists — boss plans & delegates · the workhorse
• 6 · Evaluator–optimizer — generate ⇄ critique, loop

Scaling up · & the one rule

Topologies — and start simple

Rule: every layer adds cost, latency & failure points. Use the fewest pieces that solve it.

No credit card needed

Free tokens — and a cap so the loop can't run away

• 🟢 Gemini free tier — key from aistudio.google.com, generous requests/day
• 🔵 OpenRouter — one key, many models tagged :free
• 🚦 UsageLimits(request_limit=5) → raises UsageLimitExceeded

Because agents loop, always cap the number of requests.

▶ Live first_agent.py

One tool · free model · structured output · capped

class Answer(BaseModel):
    result: int

agent = Agent("google-gla:gemini-2.0-flash", output_type=Answer)

@agent.tool_plain
def add(a: int, b: int) -> int:
    """Add two integers."""
    return a + b

out = agent.run_sync("What is 21 + 21? Use the add tool.",
                     usage_limits=UsageLimits(request_limit=5))
print(out.output.result)   # -> 42

Assume it misbehaves

Failure modes → guardrails

• Runaway loop → UsageLimits
• Bad tool call → ModelRetry
• Hallucination → structured output + eval
• Prompt injection → treat tool output as untrusted
• Unsafe action → human-in-the-loop
• Silent regressions → tracing + evals

The architecture

One design powers the whole field

• Introduced in 2017 — the paper “Attention Is All You Need.”
• It's the “T” in GPT — Generative Pre-trained Transformer.
• GPT, Claude, Gemini, Llama — all Transformers. Same idea, scaled up.

Remember the opener: a next-word predictor. This is the engine that does the predicting.

Step 1 text → numbers

First, words become numbers

Step 2 · the key idea

Attention — every word reads the others

Each token looks at every other token and decides which ones matter for what comes next.

Same word — context resolves the meaning. That's the breakthrough.

Why it mattered

Why the Transformer changed everything

You don't need the math to use it well — but now you've seen what's inside the box.