It’s that season again. People are hunting for internships, weighing job switches, starting something new. And whether you’re a student or a working professional, the same quiet anxiety shows up: Are we doing the right things? Why haven’t we cracked this yet?

A lot of that anxiety comes from how we read the field. We scroll LinkedIn and X, and what we see are outcomes — “we shipped this,” “we deployed that,” “our paper got accepted.” Those are surface-level signals. They announce results without showing the terrain underneath. If you measure yourself against a feed of finished announcements, you’ll either punish yourself or end up clueless about what to actually do next.

So instead of reading outcomes, I want to read the map. Over four months I applied to nearly a hundred companies for internships and got passed over by about 99% of them — mostly, I suspect, because internship pipelines aren’t built for experienced folks. The places that did look (Netflix, MathWorks, a few research labs) were the ones explicitly open to experience. That stings, but it also sharpens the real questions:

  1. What actually exists in AI right now?
  2. What level of work is essential — not tutorial-level, but the level the world is actually building at?
  3. What is everyone looking for?

This is my attempt at that map. I’m still figuring it out myself, so treat this as a survey, not a verdict.

The one axis that organizes everything

Picture a spectrum.

On the left, you have modeling — architectures, training recipes, how models are built and improved. This is research-flavored work.

On the right, you have systems — wiring components together to reliably get things done. This is engineering-flavored work.

Almost every opportunity in AI sits somewhere on this line. Where you should sit depends on four things: your bandwidth, your timeline, how much fundamental knowledge you already have, and how urgent your next move is. If you need a job soon, lean right and go deep on one thing. If you have room to explore — as I do right now, between courses and experiments — you can keep a couple of bets open. I personally can’t stick to just one; I’m curious by default, so I keep a small “bento box” of directions rather than a single dish. That’s a luxury, not a rule.

With that axis in mind, here are the regions of the map.

1. AI Engineering: building closed-loop systems

This is where most of the hiring is — JP Morgan, the big consultancies, life-sciences firms, Fortune 500s like Walmart and Home Depot, and the large tech companies. People call it AI engineering, agentic engineering, context engineering, harness engineering. The names don’t matter. They all mean one thing: building a closed-loop system that does a specific task and reduces uncertainty as much as possible.

The bar has moved. In 2024 and early 2025, “AI engineering” mostly meant RAG, tool calling, and basic agents. That era is over. A modern system is expected to:

  • carry real memory architectures, not just a vector store bolted on;
  • improve itself over time through memory and reasoning;
  • handle long-horizon reasoning across many steps and tools;
  • and be trained or aligned with verifiable rewards — RL environments where the task, the evaluation, and the harness are all specified.

The trap most people fall into is shallow automation: an agent that books a calendar slot or drafts an email. Those are spontaneous, one-shot actions. They don’t involve a real chain of reasoning. Compare that to the tasks the field is genuinely chasing:

  • Filing income taxes — pulling data from many documents, running calculations, reasoning about how to optimize savings.
  • Filing a medical insurance claim — assembling evidence and a chronology from scattered records.
  • Coding and software-engineering benchmarks, or Zapier-style automation benchmarks — many tools, many steps, reasoning at every layer.

Each of these needs long-horizon reasoning, which in turn needs serious memory infrastructure. That’s the craftsmanship. Very few people are building at this level, even inside companies that use AI, which is exactly why the opportunity is so wide.

If you want to be a strong generalist here, learn the runtimes and frameworks — LangChain, LangGraph, the Claude Agent SDK, the Google Agents SDK — plus the real software-engineering muscles: threading, deployment, observability. And get hands-on with RL environments: Prime Intellect’s prime-rl, Volcano Engine’s VERL, the post-training tooling on Hugging Face. For a huge fraction of careers, this region alone is enough.

2. Improving the model itself: post-training

A step to the left: instead of wiring systems around models, you improve the models themselves — their reasoning, memory, attention. In practice, for an individual, this means post-training, because pre-training the large models needs resources almost none of us have.

The most accessible version is the small language model: sub-billion or sub-7B models that you teach a specific domain — life sciences, coding, network security. The recipe has matured well past instruction tuning and DPO/GRPO. Today you reach for distillation (knowledge or policy distillation from a larger teacher) and you use RL environments to push real agent capabilities into a small model. For many enterprise “worlds” — a data platform, a networking platform, each with its own logs and dynamics — prompting and skills hit a ceiling. Training the model is what finally gives it the capability.

If the architecture side calls to you, the BabyLM challenge is the perfect playground: how do you build essential abilities — generalization, basic language understanding — from just 10 to 100 million words? It forces you to think hard about curriculum design, attention, mixture-of-experts, and decoding strategies, rather than dropping in a vanilla transformer.

Think of it as shift-left vs. shift-right: you can go deep on architectures, or deep on building systems. Pick your direction.

3. The other generative models: image, video, world

Beyond text, there’s a whole world of generative models — image generation, video generation, image editing, diffusion, and video-based world models. The most accessible path is to take models off Hugging Face and build real use cases on top. Around video generation especially, the hard, valuable work is in the scaffolding and the serving — how well can you deploy this, how fast can you make inference? (More on that in the next section, because it’s a track of its own.)

And if you want to learn the modeling, you don’t need production-scale fidelity. Most foundational diffusion and flow papers work on simple distributions anyway — MNIST, CIFAR, fluid-dynamics datasets, synthetic multivariate distributions. It’s all differential equations (stochastic and ordinary) and, increasingly, optimal transport. Put your energy into the architecture and the training recipe. You’ll learn more from transforming one distribution into another on a small dataset than from chasing high-res outputs you can’t afford to train.

4. Inference and performance optimization

This one cuts across the whole map, which is exactly why it’s easy to miss. Pre-training, post-training, and systems engineering are about building or wiring models. This is about making them run — fast, cheap, and at scale — and it matters for every kind of model: LLMs, video generators, diffusion, world models, all of it. Once a model exists, somebody has to make inference economical, and that somebody is in short supply.

The work lives close to the metal: writing optimized kernels, squeezing latency and throughput, getting more out of the same hardware. I haven’t gone deep here myself — I lean toward modeling — but I keep pointing people to it because the demand is enormous and the competition is thin. Most people resort to building surface-level agents; very few learn to make a large model serve fast. If you want leverage with low crowding, this is one of the clearest bets on the board, and the skills transfer no matter which model family you end up working on.

5. Interpretability and safety

Look at Goodfire, MATS, Anthropic — they do interpretability at different layers. It helps to separate three:

  • Behavioral — careful empirical experiments on the outputs: where do mistakes show up, is there bias, and how does that bias relate to the prompt?
  • Computation — what the model is actually doing internally.
  • Representations — where a concept or behavior lives inside the model. This is the realm of sparse autoencoders, probing, activation steering, and the newer work on neural manifolds — mapping how concepts like dates or drug categories are represented, and how those representations shift as the input changes.

The way I think about it: interpretability is system identification for control. A large model is a giant complex system; you’re hunting for a specific subsystem with a specific behavior — say, the part that handles personal information — so you can locate it, audit it, and steer it. That’s why probing and steering are no longer just research; they’re becoming design tools.

One geographic note: interpretability roles are sparse in India but dense in the US. Anyone can study it, but if you’re in the US, the opportunities are genuinely there.

6. World models and physical AI

This is research-leaning today, but I’d bet that manufacturing and engineering industries — Honeywell, GE, petrochemicals — start hiring here soon. They’ll want two things: robotics, and models that understand whole complex systems (think models built on top of IoT signals).

This is the home of VLAs (vision-language-action models) and JEPA-style architectures, which are built to digest high-dimensional signals and learn abstract representations you can plan and predict from. Representation learning matters far more here than plain language modeling.

You don’t have to train one from scratch to learn it — use an existing world model like a DINO-based one, or an off-the-shelf VLA dropped into a simulator. The papers tend to follow two steps: train the model for action-conditioned prediction, then layer model predictive control (or similar) on top to optimize the actions. And there’s always the sim-to-real gap — train in simulation, deploy in the messy real world. NVIDIA has a whole series of tools and models for exactly this. Call this region embodied or physical AI: models that take real actions and read real-world signals, not just pixels and words.

7. Pick a domain and go deep

You can also organize your career around a domain rather than a technique. Three industries each demand their own deep expertise:

  • Finance — alternative data, price indices, the meaning behind the numbers.
  • Sales & operations planning — forecasting, inventory, cost planning.
  • Life sciences / clinical — electronic health records and everything around them.

You often don’t need to train a model here — the models from Anthropic, OpenAI, or DeepMind are enough. What you need is to build a closed-loop system with real domain understanding: the data, the intermediate logic, the right tools, and — most of all — the validation and evaluation steps. And don’t be afraid to fold in classic data science: survival modeling, Box-Cox transforms, simulations. The strongest projects aren’t one agent and a web-fetch tool; they’re multiple agents, custom tools (some of which wrap smaller models), and analytical components stitched into one coherent workflow.

If you have no specific domain experience yet, the accessible on-ramps are coding and software-engineering agents, enterprise automation (Zapier-style), and BI / analytics / SQL / data pipelines — building and verifying automated pipelines with agents. Adjacent to all of this: retrievers, rerankers, and embedding models for specific domains. And if multimodal pulls at you, there’s audio, and genomics — Hugging Face just released Carbon, an open family of genomic foundation models, as one entry point into that world.

The pattern underneath all of it

Notice the shape that keeps repeating, region to region:

You either build systems (wire components together, make reasoning reliable, then earn capability through alignment or RL) — or you go research-side (take a small model or a benchmark dataset, bring your own architectural idea, and own it end-to-end from training through post-training).

Every area has its own boundary you have to operate inside. Embodied AI demands VLAs plus planning and control. Post-training demands distillation and RL environments. Interpretability demands probing and steering. They don’t all blur into one thing — and choosing your boundary is the work.

So where should you stand?

A few honest recommendations:

  • Need a job soon? Start on the right of the spectrum: AI engineering. Build a genuinely complex closed-loop system, not a tutorial clone.
  • On a tight timeline or a job switch? Pick one region and go all in. Depth beats breadth when the clock is running.
  • Have room to explore? Keep a small bento box of two or three bets and let curiosity lead. That’s where I am — running experiments across multimodal deep learning, representation learning, world models, and alignment, leaning more toward understanding model behavior than shipping systems right now. But I’ve built the systems before, and that foundation is what makes the exploration affordable.

The single rule that cuts across everything: don’t let your projects sit at the shallow, tutorial level. The YouTube-and-blog version of a project doesn’t show what industries are actually looking for. Building one level deeper — to the real range of long-horizon reasoning, real memory, real craftsmanship — is the high-leverage signal. That’s the thing the feed never shows you, and it’s the thing that’s worth your time.