Polishing & presentation

Part 1 · Theory (20 min)

Pathways to opportunities

A finished project is great. A finished project you can talk about and link to is what opens doors. Recruiters and admissions readers don't just want a grade — they want proof you can build and explain real things. That's exactly what you now have.

Framing your project on résumés & applications

Don't write "made an AI chatbot." Write in terms of the problem you solved, the tools you integrated, and the outcome. A strong bullet names the technology and the result in one breath.

The skills companies are actually looking for

Job posts say "AI/ML." What hiring managers really screen for are the habits you practiced all term. You already have stories for each of these.

Finding your way in: internship search strategy

You don't need a college degree to start. Here's how students actually break into AI/ML-adjacent roles:

• Lead with the link. In any application or message, drop your public Kaggle notebook. A clickable, working project beats a paragraph of claims.
• Search the real titles. "AI intern" is rare for high-schoolers; look wider — "data analyst intern," "research assistant," "ML volunteer," university lab openings, and nonprofit data projects.
• Go where the builders are. Kaggle competitions, local hackathons, and open-source "good first issue" tasks are portfolio and network at once.
• Message a human. A short, specific note ("I built this agent — here's the notebook — I'd love to help on X") to a professor, founder, or mentor beats a hundred cold form-fills.

Part 2 · Practical (100 min)

Polish, publish, present

Three stations, back to back. First you make the project professional, then you publish it to the world, then you present it. The full walkthrough — adding a Gradio UI, documentation, and the Kaggle publishing steps — is in the Week 5 notebook.

1 · Production polish (30 min)

Right now your project works but reads like a rough draft. Polish means someone else could open it, understand it, and run it. Do three things: comment your code, write a short README (what it does, how to run it, what you learned), and add a simple interface so it's usable without reading the code.

The friendliest interface is a tiny Gradio app: gr.Interface wraps any function in a web UI with an input box and an output box — no HTML required.

# in Colab: !pip install gradio
import gradio as gr

def run_agent(goal: str) -> str:
    """Your Week-4 agent, wrapped as one function."""
    return agent(goal)          # returns the final answer text

gr.Interface(
    fn=run_agent,
    inputs=gr.Textbox(label="Ask your agent a goal"),
    outputs="text",
    title="DataFetcher Agent",
).launch()               # pops open a shareable web app

2 · Kaggle notebook preparation (30 min)

Time to publish. You'll move your project from Colab into a public Kaggle notebook — a permanent, shareable, reproducible link. Follow the steps in order:

# 1. In Colab:  File → Download → Download .ipynb
# 2. On kaggle.com:  Create → New Notebook
# 3. File → Import Notebook → upload your .ipynb
# 4. Add a title + a markdown intro cell at the top
# 5. Run all cells top-to-bottom (check it's reproducible)
# 6. Save Version → set visibility to PUBLIC
# 7. Copy the share link — that's your deliverable

Markdown storytelling. A great notebook reads like a short story, not a code dump. Between code cells, add markdown that walks a reader through your thinking:

• Open with the problem — one or two sentences on what you set out to solve and why it matters.
• Narrate the build — a line before each section: "Here I give the agent its tools," "Now the ReAct loop runs."
• Close with results & learning — what it produced, and the single hardest thing you figured out.

3 · Portfolio presentation slam (40 min)

The finale. Everyone gives a 3-minute presentation of their project. Short and structured — three beats, roughly a minute each:

⚡ Energizer · 60-Second Hype

Before the big Slam, warm everyone up with a 12–15 minute elevator-pitch drill — it's a dress rehearsal for the 3-minute presentations, and it uses the exact same "I liked… / I wondered…" feedback you'll use all afternoon.

Your four final deliverables

This is the finish line of the whole Agent Track. Walk out with all four and you have a genuine portfolio:

• Working Colab project with documentation — commented code, a README (what it does, how to run it, what you learned), and a simple interface (Gradio or CLI).
• Public Kaggle notebook — the shareable, reproducible link with a title and a markdown story.
• 3-minute pitch — problem & agent design, a live demo or recording, and your key learning & challenge.
• Portfolio page for applications — a one-pager (or a strong résumé bullet) that frames the project and links to the notebook, ready to hand to a college or an internship.

Recap. You turned a project into a portfolio asset: you polished it (docs + a Gradio/CLI interface + peer testing), published it as a public Kaggle notebook, and presented it in a 3-minute pitch with "I liked… / I wondered…" feedback. You can name the skills employers want — tool integration, problem decomposition, iterative debugging, communication — and you have the links to prove them. That's the whole Agent Track, start to finish. Now go show someone. 🎉