The Forge Track
For CS, Software Engineering and Data Science students ready to build at industry level.
Sequential · 4 workshops
Forge is a sequential curriculum for students who want to stop using AI and start building with it properly. Four structured workshops, all working on one data pipeline that gets more complex each session.
By the end of the term that pipeline is a deployment-ready system rather than a set of exercises.
One pipeline
The same dataset, four times deeper
Unlike a set of standalone workshops, Forge runs one project the whole way through. You choose a domain dataset at the start, whether that is medical records, financial data or academic papers, and every new skill gets applied to that same data.
By workshop four you are holding a layered system: structured prompts feeding a retrieval pipeline, evaluated programmatically, with a fine-tuned model at its core.
Who it is for
- Best suited to CS, Software Engineering, Data Science and graduate students with some programming behind them.
- Third or fourth year undergraduate, or graduate. Basic Python familiarity is recommended.
- Biweekly, and each workshop builds directly on the last, so attendance matters here.
A fully functional, deployment-ready AI pipeline built incrementally across all four sessions.
Ninety minutes
15 to 30 min
Opening
What is new in AI that bears on today's topic, and why industry cares.
60 to 70 min
Hands-on build
You work in a notebook while tech leads walk the room and debug with you in real time.
10 min
Review and link forward
What got built, and what the next session does to it.
The pipeline
Structured prompting
Consistent, parseable output instead of conversation.
Retrieval
Real external knowledge grounding every answer.
Evaluation
Measured quality in place of a vibe check.
Fine-tuning
The model itself adapted to the task.
01
Programmatic prompting and structured logic
Move from conversational AI to systematic, production-grade prompt engineering.
Key skills
- Zero-shot and few-shot prompt design
- Chain of thought
- Schema enforcement with JSON and Pydantic outputs
- Prompts that produce consistent, parseable results
You build: A reasoning log: a structured system that tracks model output, classifies logic failures, and documents how to fix them across a test dataset.
- Claude API
- Python
- Pydantic
- Jupyter / Colab
02
Contextual augmentation and retrieval
Ground the model in real external knowledge to cut hallucination and raise reliability.
Key skills
- Text embedding generation
- Semantic vector spaces
- Building retrieval loops
- Dynamic few-shot retrieval by similarity search
You build: A retrieval pipeline that pulls the most relevant domain data into the prompt automatically, plugged straight into the reasoning log from workshop one.
- LangChain / LlamaIndex
- FAISS / ChromaDB
- OpenAI / HuggingFace embeddings
- Python
03
Industry tools and programmatic evaluation
Replace gut-feel testing with the deterministic evaluation frameworks used in production.
Key skills
- Developer frameworks such as LangSmith and Weights and Biases
- Observability logging
- Model-as-judge evaluation patterns
- Assertion testing and aggregate failure rates
You build: An evaluation suite layered over the existing pipeline, turning manual spot checks into measurable, repeatable metrics.
- LangSmith
- DSPy
- Python
- Custom evaluation scripts
04
Specialised optimisation and fine-tuning
Adapt a model's core behaviour for a task when retrieval alone is not enough.
Key skills
- Retrieval against fine-tuning, and how to choose
- PEFT and LoRA fundamentals
- Preparing a custom task dataset
- Open-source model adaptation
You build: A fine-tuned open-source model trained on the dataset built across the previous sessions, plus a written outcomes report covering performance boundaries, failure modes and error metrics.
- HuggingFace Transformers
- PEFT / LoRA
- Google Colab
Tools and ecosystem
- Prompting and orchestration
- Claude API, OpenAI API, DSPy, LangChain
- Vector databases and retrieval
- FAISS, ChromaDB, Pinecone
- Evaluation and observability
- LangSmith, Weights and Biases
- Fine-tuning
- HuggingFace Transformers, PEFT, LoRA, Google Colab
- Environment
- Jupyter, Google Colab, VS Code, Python
After all four
- A complete pipeline: structured prompting, retrieval, programmatic evaluation, fine-tuned model.
- A portfolio piece that survives being asked about in an interview.
- The tools, frameworks and evaluation methods AI engineering teams actually use.
- Responsible practice: you can test, measure and improve a system rather than trusting it.
- A technical network built alongside graduate students and other builders.