This guide is designed to help you prepare for my cordial juniors (kolijar tukras), but can be used as a guide to Agentic AI Engineering or Hackathon Preparation, as quickly as possible. Instead of simple chatbot interfaces, you will be building autonomous agents capable of tool use, external data retrieval (RAG), and complex orchestration. Use this roadmap to master the core technical pillars like Foundations, Orchestration, Tool-Calling, and RAG to ensure your project reaches a functional, demo-ready state.
To do well, focus on these areas:
- Foundations: Understand LLMs, Prompt Engineering, Context Engineering, Harness Engineering, Loop Engineering.
- Orchestration: Pick one framework (like the OpenAI Agents SDK) and stick with it. Don't waste time switching tools during the event.
- Tool-Calling: Practice getting your AI to use functions or external tools. This is the core skill for building agents.
- RAG (Data Retrieval): Learn how to connect your AI to your own data sources so it knows more than just what it was trained on.
- Final Demo: Prioritize building a working project that goes from start to finish. Focus on a clear result that solves a specific user need.
Use this roadmap to guide your practice, focusing on reliability and showing a clean, functional demo.
Foundations:
To understand how LLMs work, watch those videos:
- Deep Dive into LLMs like ChatGPT by Andrej Karpathy (we call him the father of LLMs): https://www.youtube.com/watch?v=7xTGNNLPyMI
- To have more understanding, what “What Makes ChatGPT Chat? Modern AI for the layperson”: https://www.youtube.com/watch?v=KvTGUI4Tznw
Don't skip this even though it's "just reading":
- Anthropic, "Building Effective Agents": https://www.anthropic.com/research/building-effective-agents
- Reference implementations of every pattern in that essay: https://github.com/anthropics/anthropic-cookbook/tree/main/patterns/agents
Then pick your orchestration stack and commit. Don't find frameworks mid-hackathon, been there, and it will waste many hours. Given the sponsor is OpenAI Codex, default to the OpenAI Agents SDK unless you have a strong reason not to.
- Official quickstart (do this hands-on, not just read): https://openai.github.io/openai-agents-python/quickstart/
- A tighter production-flavored walkthrough with 13 runnable steps (tool calls, handoffs, guardrails, FastAPI deployment), useful because it's closer to demo-ready than the bare docs: https://tech-insider.org/openai-agents-sdk-tutorial-python-13-steps-2026/
- Beginner-friendly repo with runnable scripts if you want to understand line by line: https://github.com/shahidali54/OpenAI-Agents-SDK
Tool-calling:
The problems you'll get almost certainly hinge on tool-use loops. Drill this until you can write a function-tool + agent loop cold.
- The same OpenAI quickstart above covers
@function\tool. Redo it with 3 different fake tools (a calculator, a mock API call, a file lookup) until the pattern is muscle memory, not something you're referencing docs for. This is context engineering too.
RAG (Retrieval-Augmented Generation):
Since we don't have time for a multi-week RAG course. Pick one dense, hands-on option and actually build the pipeline, not just watch it.
- freeCodeCamp's RAG + MCP crash course
- https://www.freecodecamp.org/news/learn-rag-and-mcp-fundamentals/
- It walks through embeddings, chunking, and vector DBs (Chroma) end to end with hands-on labs, and closes with MCP, which matters since the problem statements may expect tool/data integration via MCP:
- If you want a faster, narrower cut (2 hours, LangChain-based, project-oriented):
- Krish Naik's RAG crash course https://www.youtube.com/watch?v=o126p1QN_RI
- code repo: https://github.com/krishnaik06/RAG-Tutorials
Multi-agent / Orchestration Pattern:
- LangGraph playlist, hands-on multi-step/multi-agent workflows: https://www.youtube.com/playlist?list=PLKnIA16_RmvYsvB8qkUQuJmJNuiCUJFPL
- Or stay inside the OpenAI SDK and just use its native handoffs feature (simpler, one less framework to context-switch into under pressure).
Full Mock Run:
Invent a fake problem statement, set a 4-hour timer, and build start to finish:
repo init –> agent logic –> tool/RAG integration –> working demo –> README.
This is the single highest-value thing on this list. Debrief immediately after whatever step ate the most unplanned time is what you drill again before preli.
Supplementary:
- Prompt engineering reference (skim, don't study):
Top comments (0)