Get Build-Ready · NessAthon 2026

Hackathon Mindset

What Winning Teams Do Differently

Technical skill is not what separates winners from the rest. These six habits are.

Narrow wins every time

The most common reason teams lose is they tried to build too much. Pick the smallest possible complete solution on day one. One scenario, one workflow, one user. Nail it completely. A focused demo that works is always ranked above a broad demo that crashes.

Build the demo first, not last

The demo is not a bonus added at the end. It is the product. Sketch what the judge will see on 1 April before you write any code. Work backwards. Every feature that will not appear in the demo can wait until the demo works.

Measure something

"It seems to work" is not a result. Pick one metric before the sprint starts — retrieval accuracy, task completion rate, latency on 10 test inputs. Showing that your system actually performs what you claim is what separates strong submissions from weak ones.

One framework, commit to it

Pick LangChain or LlamaIndex. Pick FastAPI or Gradio. Do not switch mid-sprint. The hours spent evaluating a new framework on day five are hours stolen from the demo. The winning solution is not the most elegant — it is the one that runs cleanly on Demo Day.

Test your demo ten times

Almost every team tests their demo. Almost no team tests it ten times in a row. Run the full demo, start to finish, at least ten times before presenting. Judges remember a crash far more vividly than any feature. First click must land.

Tell a story, not a feature list

Start your presentation with a problem, not an architecture diagram. "A Ness client has this problem today. Here is what we built. Watch." Then demo. Then architecture. The teams that win every hackathon tell the best story — not the most technical one.

Learning Track

Five Phases to Demo-Ready

Follow in order. Each phase builds on the previous one. By the end you have a working prototype skeleton you can extend for any challenge area.

~4 hours total

Open any notebook directly in NeoCoder Jupyter · no pip install · no local environment setup

Phase 1 1 hour · Everyone · Watch only, no coding yet Understand what LLMs actually do

Before writing a single line of code, spend one hour here. This is not about syntax or libraries. It is about understanding why prompts behave the way they do, where models hallucinate and why, and what the context window means in practice. Every architecture decision you make during the sprint will be more grounded after this.

YouTube · Free · 1 hour · Andrej Karpathy

Intro to Large Language Models

Andrej Karpathy · Former Director of AI at Tesla · Co-Founder of OpenAI

A clear mental model of how LLMs work, where they are reliable, and precisely where they break.

Consistently rated the single best introduction to LLMs by the global developer community. No marketing, no hype. Karpathy explains how these systems actually work under the hood — tokenisation, attention, the context window, and why hallucinations happen structurally, not randomly. One hour. No code. Pure understanding.

Watch on YouTube →

Phase 2 90 min · Everyone · Open notebooks in NeoCoder and run them Build your first GenAI application

Open the GitHub repository in NeoCoder and work through Lessons 1 to 6 only. Each lesson is split into a short concept section and a working build section. Run every notebook. By the end of Lesson 6 you will have built a text generation app, a chat app, and a basic semantic search with embeddings. No background in AI required.

GitHub · Microsoft · Free · Python and TypeScript · 80,000 stars

Generative AI for Beginners

Microsoft · 21-lesson curriculum · Compatible with any LLM provider including the NeoCoder environment

A working chat application and a semantic search prototype — both running in NeoCoder by end of Lesson 6.

The most widely used structured GenAI curriculum available. Every lesson ships with runnable Jupyter notebooks — open them in NeoCoder and run them directly, no local setup. The same code works with any LLM API including what is available on the NeoCoder platform. Do Lessons 1 through 6 only — that is around 90 minutes and covers everything you need for Phase 3.

Open on GitHub →

Phase 3 90 min · Everyone · Runnable notebooks in NeoCoder Connect AI to documents — build your first RAG

RAG (Retrieval-Augmented Generation) is the pattern behind almost every enterprise AI solution in both challenge areas. You load a document, break it into chunks, store it in a vector database, and let the LLM answer questions using only what is actually in the document — not what it guessed. This is the single most important technique to learn before the sprint. The second half of this course shows you how to measure whether your RAG actually works, which is what judges ask about.

DeepLearning.AI · Free · 1 hr 55 min · Runnable Jupyter notebooks

Building and Evaluating Advanced RAG

Jerry Liu, CEO of LlamaIndex · Anupam Datta, Snowflake AI Research

A complete RAG pipeline that loads documents, retrieves relevant chunks, and returns grounded answers — plus an evaluation harness that scores whether it is actually working.

Do not be put off by "Advanced" in the title — the first half is straightforward and builds the core RAG pattern step by step. The second half covers evaluation: how to measure retrieval quality, groundedness, and answer accuracy. This matters because teams that can show a metric always rank above teams that only say "it works well." All notebooks run directly in NeoCoder Jupyter.

Start course →

Phase 4 60 min · Pick one path based on your challenge area Build for your challenge area

Pick the path that matches your challenge area. If you are still deciding between areas, both courses teach the same core agent pattern — the difference is in how agents are used. Area 1 builds agents that reason about business tasks. Area 2 builds pipelines that automate engineering workflows.

Area 1 · AI solutions for business functions

HuggingFace · Free · Units 0 and 1 · 2025 curriculum

AI Agents Course

HuggingFace · Covers smolagents, LangGraph and LlamaIndex

An agent that receives a business question, decides which tools to call, retrieves relevant information, runs a calculation if needed, and returns a structured answer to a human reviewer.

Units 0 and 1 only — around 60 minutes. Covers the fundamentals of how agents decide what to do next, how tool calling works, and how to build an observation loop. Do this and your Phase 3 RAG becomes the knowledge base your agent queries. The architecture maps directly to Area 1 challenge scenarios.

Start course →

Area 2 · AI native operating model in PDLC

DeepLearning.AI · Free · 1 hr 32 min · Runnable notebooks

AI Agents in LangGraph

Harrison Chase, CEO of LangChain · Rotem Weiss, CEO of Tavily

A stateful multi-step pipeline that runs several LLM steps in sequence, remembers results between steps, and includes a human-in-the-loop checkpoint before taking a final action.

Taught by the person who built LangChain. LangGraph is the right tool for Area 2 solutions because PDLC workflows are inherently stateful — a code review agent needs to remember what it found in step one when writing its report in step three. Covers persistence, streaming, and human-in-the-loop patterns that map directly to the example topics in Area 2.

Start course →

Phase 5 20 min · Everyone · Read quickstart section only Wrap it in a demo that works on first click

This is the final step between your working pipeline and a Demo Day presentation. Judges interact with demos, not code. Gradio turns any Python function into a web interface in about 20 lines. Read only the Quickstart section. Connect it to the pipeline you built in Phase 3 and you have a complete end-to-end demo ready to share.

Gradio Official Docs · Free · 20 min · Built by HuggingFace

Gradio Quickstart

Gradio · HuggingFace · The demo tool of choice at every major AI hackathon

A working web interface — text input, AI response output, shareable link. No deployment needed. The judge opens a URL and interacts with your solution directly.

Read the Quickstart section only. That is genuinely all you need. Gradio wraps your Python function in a clean UI that any non-technical judge can use without instructions. Wire it to your Phase 3 RAG pipeline or Phase 4 agent and you have a complete demo. A working shareable link is the difference between "we built it" and "watch it work."

Read quickstart →