AI Research Residency
A first-person AI course built around code, experiments, evals, and public proof of learning.
This is the public course-shaped version of the AI Residency work I’m building. I wanted something more demanding than a reading list and more honest than saying I’m “into AI research” without showing the work. So the residency is organized around modules, implementation notes, experiments, proof-of-mastery artifacts, and a growing repo that makes the learning legible.
The sequence moves from foundations into research-adjacent systems: transformers, training, retrieval, agents, evals, benchmarks, observability, safety, and eventually a capstone that should feel like a real public artifact instead of a private exercise.
I also like this format because it matches how I actually learn. A concept becomes more real for me once I can implement it, explain it in plain language, test it, and connect it to a system someone else can inspect. That is the throughline between this residency, the evals and agent-systems writing on the site, and the smaller interactive products I’ve been building.
There is an AI-assisted loop around the work too, but the point is not to outsource understanding. The current split is simple: conversational coaching for orientation and debugging, then repo maintenance that turns sessions into durable notes, code, tests, checklists, and public pages.
Good starting points: AI Residency repository, Curriculum overview, Residency roadmap, Learning system, Residency Coach brief, and Transformer from scratch note.
1. Transformers From Scratch
Implement embeddings, attention, blocks, logits, and generation until the tensor shapes actually make sense.
2. Training and Evaluation
Build experiment hygiene, loss tracking, and model-comparison instincts instead of treating training as a black box.
3. Data, Embeddings, and RAG
Work through retrieval quality, grounding, datasets, and where RAG meaningfully helps or hurts a system.
4. Agents and Tool Use
Study tool contracts, planning loops, memory, failure modes, and what makes an agent workflow durable.
5. Multimodal Systems
Explore vision, audio, and interface-shape questions rather than assuming chat is the only useful surface.
6. Evaluation and Observability
Learn benchmarks, eval design, tracing, regression gates, and what evidence should exist before a system ships.
7. Alignment and Safety
Work on red teaming, policy design, safety review, and how residual risk should be documented honestly.
8. Research Methods
Read papers, reproduce claims, run ablations, and write memos that are actually inspectable.
9. Systems and Deployment
Cover serving, latency, monitoring, cost, and the operational side of getting research-shaped work into the world.
10. Capstone
End with a public research artifact that includes code, evaluation, documentation, and a real explanation of what worked.
The current version is intentionally practical. Every module is supposed to leave behind evidence: runnable code, a note, a diagram, an eval artifact, a failure analysis, or a public write-up. If it does not create proof, it probably does not count yet.
If you are trying to understand the part of my work that leans toward evals, benchmarks, agent systems, and research-adjacent product thinking, this page is one of the clearest entry points.