My self-built program to do real research engineering at a frontier lab — and the structure that keeps it honest.

For a while I was building the way most people build when they’re trying to break into something hard: a project here, a project there, whatever caught my attention that week. A diffusion model because diffusion was everywhere. A fine-tuning experiment because someone shipped one on Twitter. A scraper, a notebook, three half-finished repos. Each thing was fine on its own. Together they were noise.

I’d open LinkedIn, see someone my age at a lab I want to be at, and the familiar voice would start — why am I not doing that? — so I’d pick up something new, and the pile would grow, and the pile still said nothing about me.

The problem was never effort. I had plenty of effort. The problem is that effort without a spine doesn’t compound. It just accumulates. And a pile of accumulated effort is exactly as impressive as it sounds: not very.

So I built FAIRE — Frontiers in AI Research and Engineering. It’s not a course or a checklist. It’s the operating system I run my own development on: a single program that turns scattered curiosity into a compounding body of work, pointed at one outcome — doing research engineering at a frontier lab. This post is the narration of what it is and how it’s put together.

The governing idea: arc of work, not proof of work

Everything in FAIRE follows from one distinction.

Proof of work says look how much I’ve done. An arc of work says look how I think.

The difference is sequence. In an arc, the second thing grows out of the first. The third answers a question the first two raised. By the time you reach the fifth, someone looking at it can see a mind that builds on itself — not a collector, but a compounder.

I noticed this in my own work before I named it. One semester I built explicit causal graphs for user behavior modeling. The next project took user behavior from search and recommendation systems and learned a causal representation on top of it. Two projects, but really one thread — the same question pulled deeper. That thread is worth more than ten unrelated repos, because it shows direction. A lab isn’t hiring your repository. It’s hiring the trajectory the repository implies.

FAIRE exists to make sure I’m always building toward something, and that each new thing extends the line instead of breaking it.

The structure: a pyramid with four layers

FAIRE has a shape. I think of it as a pyramid — foundations at the bottom, evidence at the top.

Layer 1 — Curriculum

The base. The foundations, the slow layer, the part you don’t get to skip. It’s mostly behind me now after a year of coursework and six years of industry before it, but it stays live as a log. I keep ten tracks running in parallel, because each one maps onto several things above it:

  1. AI — large language models (LLMs), vision-language models (VLMs), vision-language-action models (VLAs), multimodal foundation models, pre-training & next-token prediction, supervised fine-tuning, RLHF & RLAIF, instruction following, tool use & function calling, agentic architectures, multi-agent systems, evaluation & benchmarking, mechanistic interpretability, alignment & safety, frontier model engineering.
  2. Generative Modeling — autoregressive models, VAEs, GANs, normalizing flows, diffusion & score matching, SDEs, flow matching, optimal transport, energy-based and latent-variable models.
  3. Representation Learning — self-supervised pretraining, contrastive learning (SimCLR, MoCo, CLIP), masked autoencoding, joint-embedding architectures, JEPA & predictive coding, multimodal alignment, vision-language models (VLMs), vision-language-action models (VLAs).
  4. Neural Networks & Deep Learning — CNNs, RNNs/LSTMs, attention & transformers, GNNs, optimization, regularization, training dynamics, normalization, scaling laws, efficient inference.
  5. Statistical & Probabilistic ML — MLE, Bayesian inference, graphical models, MCMC, variational inference, Gaussian processes, mixture models & EM, uncertainty & calibration, probabilistic programming.
  6. Reinforcement Learning — MDPs, Bellman equations, Q-learning & DQN, policy gradients, actor-critic, PPO, model-based RL & world models, offline RL, RLHF & reward modeling, multi-agent RL, game theory.
  7. Attention, Memory, Reasoning & Continual Learning — attention variants, long-context methods, chain-of-thought, retrieval-augmented generation, memory-augmented networks (Hopfield, NTM, DNC), continual learning, catastrophic forgetting.
  8. Causal & Statistical Inference — structural causal models, potential outcomes, treatment effects, IVs, diff-in-diff, regression discontinuity, causal discovery (PC, GES, NOTEARS), counterfactuals, causal representation learning.
  9. Algorithms & Systems for AI — algorithms & complexity, data structures, vector databases & ANN indexes, GPU programming, data/model/pipeline parallelism, quantization, distillation, ML compilers (XLA, Triton), MLOps.
  10. Complexity, Cognition & Natural Intelligence — complex dynamical systems, nonlinear dynamics, emergence, adaptive control, cognitive science, neuroscience, embodied cognition, scientific discovery, AI for the life and physical sciences.

The tracks aren’t silos. RL shows up in post-training, in world models, in decision-making. Probabilistic modeling and deep learning thread through nearly everything. That overlap is the point — the curriculum is the shared vocabulary that the arcs draw on.

Layer 2 — Research arcs

On top of the curriculum sit the research arcs — the long lines of inquiry, where the tracks get mixed and matched into actual work. I keep six on the map:

  1. Post-training, interpretability, safety, steering & control — how models are shaped after pre-training, and how we understand and govern what they do.
  2. Generative modeling, world models & multimodality — from-scratch diffusion and flows up through optimal transport and multimodal systems; VLMs and VLAs as the applied frontier of this arc, with RL threaded through.
  3. ML & AI systems — training and inference at scale; the engineering that makes everything else run.
  4. Advanced deep learning — architectures, training algorithms, and paradigms (self-supervised lines like SimCLR → DINO, and the rest), implemented and probed.
  5. Decision engineering — real-world problem solving with AI, where six years of industry experience gets squeezed into systems that ship.
  6. Scientific discovery & AI-for-X — therapeutics, embodied and physical AI, life and biological sciences.

These six are a map of where work can live. They are not six things to do at once — and that distinction is the single most important rule in FAIRE. I’ll come back to it.

Layer 3 — Projects

Inside each arc live the projects — meticulous, cumulative, each one a step that builds on the last. Not standalone demos. Links in a chain.

Layer 4 — Capstone

The projects, stacked, become a capstone: the evidence that I’ve walked an arc end to end and have something real to say about it. The capstone is what I show. When I apply somewhere, I don’t dump everything — I sample. I take one arc and say: here is where I started, here is where I ended, here is what I learned in between. One clean line beats a scattered portfolio every time.

Two principles that run through every layer

Mastery and mattering. Mastery is what I develop for myself — depth, fluency, the ability to build a thing from first principles and know why every piece is there. Mattering is what the work is worth to the people I’m trying to reach: a specific lab, a specific team, a specific problem they care about. Mastery without mattering is a beautiful hobby. Mattering without mastery collapses under one good interview question. FAIRE only counts work that lands in the intersection.

And the arcs aren’t equally legible to every target. A post-training-and-interpretability arc speaks to one kind of lab; a world-models-and-multi-agent arc speaks to another. So choosing which arc goes live isn’t logistics — it’s the targeting decision itself.

How you walk an arc. Every arc gets walked the same way, which turns an intimidating field into a sequence of moves. You start small and from scratch — the toy version, coded by hand, until you’ve earned the intuition. Then you study the field properly, state-of-the-art and test-of-time side by side, until you can see the open edges. Then you extend — take a real model and run a real experiment, break it, probe it, push it somewhere new. And finally, where the constraints allow, you add originality: on a tiny model that might be a clean from-scratch idea; on a giant one you can’t retrain, it’s an optimization, an extension, a new domain. Reproduce, extend, originate. Each step is a public artifact. The arc is the story that threads them.

How I run FAIRE

Not metaphorically — operationally. I treat myself like a startup: capabilities to build, but also positioning, a thesis, partnerships, a network, and a balance sheet of time. The outputs vary — a workshop paper, a product, a reproduction, a writeup, an experiment that failed honestly. I count the failures, because a failed JEPA experiment still leaves the understanding behind, and understanding is the asset.

The startup framing forces the discipline I most needed. Right now I run two arcs, not six. Half a day on one, half on the other. The other four stay on the map, patient, and I don’t touch them. The first time I tried to keep all of them “alive,” I just recreated the scatter I was escaping, with nicer labels. Depth doesn’t divide by six.

Outcome is one. Output is many.

There is exactly one outcome FAIRE is built toward: doing real research engineering at a frontier lab. That north star doesn’t move.

The output can be anything — papers, projects, products, reproductions, essays, threads, even honest failures. I don’t get attached to the form. I get attached to whether each piece extends an arc and moves me toward the outcome.

So the daily test is simple, and it’s a test FAIRE itself can fail: did I produce a piece of an arc, or did I just produce a prettier description of FAIRE? The map is not the territory. The pyramid is not the work. The work is the next artifact, shipped, in one live arc, this week.

Everything else is just me getting organized enough to begin.