MLA 030 AI and Programming Jobs in 2026: What Actually Happened, and How to Position

One thing to know up front. Gnothi made this episode. It's a tool I built: name a topic, and it researches the subject, writes chapters, and narrates them.

This is the job market episode. It stands on its own, but it's the coda to the three vibe coding episodes, Vibe Coding in 2026, Inside a Coding Agent, and Agentic Software Engineering, and to the two agents episodes, AI Agents in 2026 and OpenClaw and the Personal Agent. Those covered the tools and how to run them. This one asks the question that comes up most: what did all of that do to programming and machine learning jobs, which skills held their value, and what should you do about it. I'm going to do this in three moves. Evidence first, the actual numbers as of this recording. Then mechanism, why the numbers look the way they do. Then positioning, what a working programmer or an aspiring ML engineer should be doing this year. No doom, no cope.

Let me start with a distinction that will carry the whole episode, because most of the bad takes come from collapsing it. There are two different things people mean when they say AI is taking programming jobs. One is displacement: the job goes away, the person is let go, nobody is hired to replace them. The other is task change: the job stays, the person stays, but what they do all day shifts. Those two things show up in completely different data. Displacement shows up in unemployment rates and layoff announcements. Task change shows up in what job postings ask for, in how teams are shaped, in what a senior engineer does with a Tuesday afternoon.

The distinction decides your response. If the story is displacement, the right response is defensive: get out of the exposed role, retrain, hedge. If the story is task change, the right response is offensive: get fluent with the tools faster than your peers, move your work up the stack to the parts that grew. And my read of the data, which I'll walk through, is that the aggregate is mostly task change, with one real pocket of displacement at the entry level. So the advice at the end is going to be offensive for most listeners and defensive for one group, and I'll be specific about which group.

One more framing note. A lot of this debate is people quoting the half of the evidence they like. The accelerationists quote the entry-level numbers and ignore the aggregate. The skeptics quote the aggregate and ignore the entry-level numbers. I'm going to try to hold both in the same hand, because both are true at the same time, and the interesting question is how.

So that's the frame. Now the evidence, and I'll try to give you the source for each number so you can go check it.

Start at the top, the whole economy, because that's the claim that got the most press. In the spring of 2025 the CEO of Anthropic, Dario Amodei, told Axios that AI could wipe out half of entry-level white collar jobs and push unemployment to ten or twenty percent within one to five years. That's the bloodbath quote. As of this recording, the most recent Bureau of Labor Statistics employment report has unemployment at four point one percent, unchanged, with payrolls growing faster than forecasters expected. You'd need it to roughly triple to get into the bottom of Amodei's range. On the aggregate, that prediction is not close, and both Amodei and Sam Altman have softened their language this year. Altman said, in an interview this past spring, that he was delighted to be wrong, that he'd expected more impact on entry-level white collar jobs by now than has actually happened. Hold onto that quote, because a forecaster scoring his own forecast is rare in this debate.

The Yale Budget Lab runs a rolling tracker on this and their language is "no discernible disruption" across the nearly three years since ChatGPT shipped. Goldman Sachs Research, which is not a firm with an incentive to downplay a tech story, put a number on it this summer. Across more than eight hundred occupations they estimate AI is a net drag of about sixteen thousand jobs per month, roughly twenty-five thousand substituted and nine thousand added back through augmentation, and they put the long-run baseline at six or seven percent of workers displaced. Sixteen thousand a month in an economy that adds a hundred and fifty thousand in a decent month. Real, measurable, and about two orders of magnitude below bloodbath. That's the aggregate.

Now the pocket. The most important study for this episode is called Canaries in the Coal Mine, by Erik Brynjolfsson and colleagues at the Stanford Digital Economy Lab, using payroll data from ADP, the payroll processor, which covers millions of American workers. It came out in the summer of 2025 and they updated it in August 2026 with data through June. The headline: workers aged twenty-two to twenty-five in the occupations most exposed to AI are now nineteen percent behind where they'd be if they'd kept pace with their less-exposed peers of the same age. And that gap is widening. It was fifteen percent in July 2025, sixteen by November, nineteen by June 2026. Experienced workers in the same occupations show no comparable gap.

Three details from that paper matter more than the headline. First, the gap comes from reduced hiring, not from firings. Companies aren't laying off their twenty-four year olds. They're not hiring the next twenty-four year old. Second, the decline concentrates in occupations where AI usage looks like automation, doing the task instead of the person, and is flat to rising where usage looks like augmentation, doing the task with the person. Third, the authors are careful. They say the patterns attenuate when you control for education, that some of the trend predates generative AI, and that they're stronger in the ADP sample than in national surveys. They call these descriptive indicators, not causal estimates. That's the right level of confidence and I'd ask you to carry it too.

There's a twist for software specifically, which I have not seen anyone report. The paper has a case study on software developers. The sample of young software developers in the government survey is so small, a few dozen people per month, that the authors won't stand behind a software-specific employment percentage, and neither will I. But the compensation finding is interesting. For twenty-two to twenty-five year old software developers, pay grew somewhat faster than for older developers after ChatGPT. The authors offer the mechanism themselves: if firms stopped hiring the lower-paid junior engineers, the average junior who does get hired is a better-paid one. Fewer doors, but the doors that open pay better. That's a very different story from "AI killed the junior dev." It's "AI raised the bar for the junior dev."

Now the software-specific demand signal, which is the number I'd put on a slide if I used slides. Indeed publishes an index of software development job postings, and the Federal Reserve mirrors it on its FRED data site. February 2020 equals one hundred. As of this recording it's sitting around seventy-five. Software postings are about a quarter below the pre-pandemic baseline and still drifting down. And total postings across the economy are nowhere near that far down. Software is idiosyncratically weak. Now, the confounds. Interest rates went up in 2022 and startup funding collapsed. A tax change in the United States, section one seventy-four, made it much more expensive to expense engineer salaries for a few years, and the Canaries authors themselves flag that as a rival explanation. And big tech overhired massively in 2021. So some of that twenty-five percent is the hangover, not the robot. But the index kept sliding after rates started coming down, which is hard to explain without the tools.

The new grad piece is worse and it predates ChatGPT. SignalFire's talent report found new graduates were just seven percent of big tech hires, down twenty-five percent from 2023 and down more than half from 2019. Read that 2019 baseline again: half the collapse in new grad hiring at big tech happened before anyone had a chat model. Smaller teams, smaller funding rounds, and then AI absorbing the routine work a junior would have done. It's a stack of causes and AI is the most recent layer on it.

Now the layoffs, because every week there's a headline. Challenger, Gray and Christmas tracks announced job cuts and the reason the company gave, which is the useful part. Through August of this year, about a hundred and sixteen thousand of the five hundred and thirty thousand announced cuts were attributed to artificial intelligence, roughly twenty-two percent, and that eight-month figure is already more than double the AI-attributed total for all of last year. From March through July, AI was the number one stated reason every single month. So that's real and it grew fast. But two things cut the other way. Total announced cuts for the year are down forty-one percent from the year before. And in August the AI-attributed number collapsed to about three and a half thousand, the lowest month since last December, ending the streak. Both camps quote this report and both are telling the truth. My read: AI has become the socially acceptable reason to give for a cut you were going to make anyway, and also a genuine reason for some of them, and the reports can't tell those apart. Neither can I.

Two more readings that sharpen the software picture. The New York Fed publishes labor outcomes for recent college graduates by major. In the latest release, computer science majors have about seven percent unemployment and computer engineering nearly eight, against about five and a half percent for all recent grads. Computer engineering is the second-worst major on that list, computer science the fourth. But their underemployment, meaning working a job that doesn't need the degree, is around sixteen to nineteen percent, against forty-two percent for all majors. So the computer majors are the worst on getting a job and among the best on getting a good one once they do, which is the same "fewer doors, better doors" shape again. And CompTIA's monthly tech jobs read has tech occupation unemployment at about two point eight percent, with something like three hundred and twenty thousand active postings asking for AI-related capabilities. The people already in the field are fine. The people trying to get in are not.

There's also a reversal wave. CNBC ran a piece this summer on employers who laid off workers for AI and then reversed. Forrester's future of work report found fifty-five percent of employers regretted AI-related layoffs. Robert Half found nearly one in three hiring managers in the United States had cut a role citing AI and then refilled it or a comparable one. Klarna is the canonical case: replaced around seven hundred customer service staff with a chatbot, customer satisfaction cratered on the emotionally charged cases, and they hired humans back. IBM, by the same reporting, automated most of its routine HR requests and found the small remainder, the edge cases, the ones needing judgment, were the whole job, and is reportedly expanding entry-level hiring. I'll note the IBM specifics reached me only through secondary coverage, so take them as a shape, not a figure. But the shape is consistent across cases: the ninety percent that automates is not where the value was.

And then the projections. The Bureau of Labor Statistics, in its current ten-year outlook with a 2025 base year, projects software developer employment to grow ten percent, which it calls much faster than average, from about one point seven million. Data scientists, thirty-five percent. And computer programmers, the occupation defined as writing code to someone else's spec, minus seven percent. That's the whole augmentation thesis in two rows of a government table. The hundred-thousand-person occupation whose job is implementation shrinks. The million-and-a-half-person occupation whose job is design, judgment and ownership grows. I'll come back to that split, because it's the mechanism.

One last piece of evidence, and it's about the evidence itself. In the summer of 2025 the research group METR ran a randomized controlled trial with sixteen experienced open source developers on two hundred and forty-six real issues in their own repositories, randomly allowing or forbidding AI tools, mostly Cursor with Claude. The developers were nineteen percent slower with AI. They'd predicted a twenty-four percent speedup going in. And after the study, having been measurably slowed down, they still believed the AI had sped them up by twenty percent. I want to be careful about what this does and doesn't show. It was early 2025 tooling, on mature codebases the developers knew intimately, which is the worst case for an agent. My own experience with 2026 agents on my own codebases is not a nineteen percent slowdown. But the perception gap is the durable finding. Self-reported productivity from AI is unreliable, in both directions, and that means a big share of the survey evidence both camps wave around should be discounted.

So, the evidence, summed up. Aggregate employment fine. Entry-level in exposed occupations degraded and widening, driven by hiring, not firing. Software postings a quarter down with multiple causes stacked. Layoffs increasingly labeled AI while total layoffs fall. Programmers projected to shrink while developers and data scientists grow. And the people doing the work can't accurately tell how much the tools help them. That's the evidence. Now the mechanism behind it.

The mechanism in one sentence. When the cost of implementation drops toward zero, the value moves to the things around implementation: deciding what to build, verifying that what got built is right, and knowing the domain well enough to do either. Let me take those one at a time, because they map directly onto what got commoditized and what got scarcer.

What got commoditized is the translation of a clear spec into working code. That's what a coding agent does. Give it a well-specified issue, a test that defines done, a repo with instruction files, and it produces the change. In the earlier episodes I walked through exactly how that works, and if you run one you know the feeling: the part of the job that used to be the job is now something you review rather than do. The BLS "computer programmer" category is precisely this translation function, and it's the one they project to shrink. That's the definition of the occupation meeting the definition of the tool.

What got scarcer is the first thing around implementation, specification. Andrew Ng has been the clearest voice on this. His argument, restated across his newsletter through this year, is that as AI automates coding, developers get pushed up into the work that used to be reserved for senior engineers: deciding architecture, scoping product requirements, shaping what gets built rather than implementing a spec someone handed you. He ran a whole series this summer on the skills map for an AI engineer and the throughline is that the bottleneck moved from how to build to what to build. If you've tried to run an agent on a vague ticket, you've experienced this from the other side. The agent's output quality is almost entirely a function of your spec quality. The scarce input became the spec.

The second thing around implementation is verification, and I think this is the underrated one. An agent produces plausible code fast. Plausible is the danger word. Somebody has to decide whether it's correct, whether it handled the edge case, whether it quietly rewrote the test to pass. In the Agentic Software Engineering episode I said verification is the product, and the labor market version of that is: the person who can look at ten thousand lines of agent output and know in twenty minutes which two hundred are wrong is worth more than they were three years ago. That's why the senior gap in the Canaries data is flat. Seniors are the verifiers. The tools multiplied their judgment instead of replacing it.

The third is domain. One way to see it. A coding agent knows more about React than any junior developer ever will. It knows nothing about your customer's billing edge cases, about which regulation applies to the data you're handling, about why the last three attempts to fix this subsystem failed. That knowledge doesn't live in the training data, it lives in people who've been in the building. When implementation gets cheap, the person who knows what a correct answer even looks like in this domain is the constraint. David Autor at MIT has a phrase for this, that AI is a supplement to a worker with judgment and domain knowledge, not a replacement for one. I'd put it more bluntly: the agent is a very fast intern with no memory of your business, and interns are only useful to people who know what to ask for.

Now, why does this hit juniors and not seniors, mechanically? Because the traditional junior role was exactly the commoditized part. You got hired to implement well-specified tickets, and in doing so, over years, you absorbed the domain and learned to verify. The implementation was the tuition. Now the tuition is free and the school is closed. The senior still has all three skills. The junior is being asked to arrive with two of them, specification and verification, that used to be learned on the job. That's the raised bar the Canaries compensation data hints at. Companies still want twenty-four year olds. They want the ones who already work like twenty-eight year olds, and they'll pay for those.

There's a second-order effect worth naming. Ng's Davos line this year was that for most jobs AI can do thirty or forty percent of the work now, and you still need a person for the rest, and the person who uses AI will replace the person who doesn't. That last clause is the actual displacement mechanism in most companies. A human with agents replaces a human without them, at the same desk, in the same headcount. Which is why the aggregate numbers barely move while every individual's job changes.

And there's a limit on the mechanism that the skeptics are right about, and it matters for how far this goes. Two benchmarks from this year, side by side. OpenAI's GDPval measures whether a model's output on a realistic professional deliverable is as good as an expert's, and the newest models win or tie against experts in a large majority of tasks, north of eighty percent in the latest published number, though I'd note that win-or-tie is a generous framing and that much of the grading is automated. Then there's Scale's Remote Labor Index, which asks a different question: can an agent complete a real, multi-day freelance project end to end, to the standard a client would pay for. The best system as of this spring completed about four percent of them. Same year, same models. Eighty percent on a one-shot deliverable, four percent on an unsupervised multi-day project. That gap is the mechanism. Agents produce artifacts. Humans run projects. Until the second number moves, the job is the project, and the job stays.

So that's why the numbers look the way they do. Now let's get specific about the ML career, because this show is called Machine Learning Applied and a lot of you are here for that, not for web development.

The first thing to say is that the ML career and the software career diverged. The BLS row for data scientists is plus thirty-five percent, three times the developer growth. The compensation sites put the ML-focused software engineer in the United States averaging somewhere around a quarter of a million dollars total comp, and while I won't quote a premium percentage from a single site, the direction is not ambiguous. AI ate software's entry level and, at the same time, created a whole new tier of software jobs whose subject matter is AI. If you're trying to decide whether to move toward the models or away from them, the demand signal says toward.

But the word "ML engineer" has splintered, and the split matters for what you learn. Let me give you the taxonomy as it exists in postings this year, five roles, in rough order of how many people they employ.

The biggest is the AI engineer, application layer. This is the person who builds products on top of models they didn't train. Retrieval, tool use, agent loops, evals, prompt and context design, the plumbing between a model and a user. It's mostly a software engineering job with a new set of primitives, and it's the role Ng's skills-map series is describing. It does not require you to know how to backpropagate. It does require you to understand what a context window is, why a model fails on a given input, and how to build a harness that catches the failure. Most of the growth in AI postings is here.

Second, and growing fast, is the forward-deployed engineer. The name comes from Palantir, and the big labs adopted it; as of this recording Anthropic's own job board has forward-deployed openings in several American cities and in Europe, plus managers for the function, so it's a team, not a title. This is an engineer who sits with a customer and makes the model work for that customer's actual problem, which is almost always a domain problem, not a model problem. It's the purest expression of the mechanism I described: implementation is cheap, domain is the constraint, so ship an engineer to where the domain is. If you have a domain already, healthcare, finance, logistics, law, and you can code, this role was built for you.

Third is the evals and AI quality role. Somebody has to answer the question "is it good," repeatably, in a way you can put in your continuous integration pipeline. Building task suites, grading rubrics, judge models, regression tracking, red-teaming. Two years ago this was a slide in a talk. Now it's a job family, with titles like research engineer for model evaluations and evaluations engineer on the same lab boards, and it's arguably the most under-hired one relative to how much it's needed. The METR study I mentioned is a good example of why: without measurement, everyone's intuition about whether the model helps is wrong. If you like being the person who proves things rather than the person who claims them, look here.

Fourth is infrastructure: inference, serving, platform. Someone runs the GPUs, batches the requests, quantizes the model to fit the budget, builds the training pipeline, keeps the thing at four nines while the model version changes weekly. This is the closest thing to the old MLOps role and it's the most durable, because every model, from every lab, needs it, and it's hard. It also rewards people who came from systems and distributed computing rather than from statistics.

Fifth, smallest and most competitive, is research: research engineer and research scientist at the labs and the well-funded startups. Pretraining, post-training, alignment, architectures. This is the job people picture when they say "ML," and it is a few thousand seats globally, filled largely from a short list of universities and prior labs. I'm not going to tell you not to try, but I am going to tell you that the other four roles are where the hiring is, and that the skills that get you a research seat, the math, the papers, the ability to run a clean experiment, are also the skills that make you the best person in the room in the evals role, so the paths aren't as separate as they look.

So, compressed, what "AI engineer" means now. It means a software engineer who treats the model as a component with a failure distribution rather than as a library with a contract. The work is designing the system around the failure distribution: retrieval so it has the facts, tools so it can act, evals so you know when it's wrong, and guardrails so the wrongness is bounded. Most of what's in the agents episodes is this job's curriculum.

And a word on what didn't hold value, because plenty of things that looked durable turned out to be temporary. Prompt engineering as a standalone title is mostly gone; it became a skill every engineer is assumed to have, the way SQL did. Fine-tuning as a default move lost ground to better base models plus retrieval plus good context, and it's now a specific tool for specific cases rather than the first thing you reach for. And the pure "train a model from scratch on our data" job that dominated ML hiring a decade ago has been pushed down to the infra and research tiers. If your resume is built around the 2018 ML engineer, you're describing a job that mostly moved.

Okay. So that's the ML side. Now the part where I try to be fair to the people who disagree with each other, because you'll be asked at dinner which of them is right.

There are three camps, and I'll give you the best version of each. The accelerationists: Amodei, Altman, Mustafa Suleyman at Microsoft AI, and a chunk of the investor class. Their claim is that disruption is one to five years out, that entry-level white collar work is first, and that the models are on a curve that doesn't flatten. Suleyman said in an interview this past winter that most tasks done sitting at a computer would be fully automated within twelve to eighteen months. The best version of this camp's argument is the benchmark curve: the GDPval numbers went from roughly ten percent to north of eighty in about eighteen months, and if you extrapolate that, you get their world. What's gone wrong for them so far is the aggregate: unemployment hasn't moved, and their own two leading voices have walked back the timeline this year. Suleyman's clock hasn't run out yet. I'd bet against it, but I'd note that these are the people who see the next model six months before you do, and their incentive to talk up disruption right before their companies go public is a real thing you should factor in, in both directions.

The skeptics: Yann LeCun, Gary Marcus, and on the economics side Daron Acemoglu. LeCun left Meta at the end of last year saying language models are a dead end and started a company, AMI Labs, to build world models instead, and raised what's reported as the largest seed round in European history to do it, which is a funny thing for a skeptic to do and also a serious signal about where he thinks the ceiling is. Marcus argues most white collar jobs aren't going anywhere soon and that the panic is largely industry marketing. Acemoglu's paper on the macroeconomics of AI put the ten-year productivity gain at well under one percent. The best version of this argument is the Remote Labor Index number: four percent completion on real multi-day work. If that's the ceiling, the accelerationists are wrong and the job market stays roughly intact. Where the skeptics are underestimating is the cheap-but-imperfect case. A tool doesn't need to replace a worker to reshape the job market; it just needs to make one worker do the work of one and a half, and the entry-level data says that's already happening.

The pragmatists: Ng, Brynjolfsson, Autor. Their position is that the technology is real, the effects are uneven, and the useful question is not "when does it take the job" but "which tasks move, and what should you do about it." Brynjolfsson wrote the canaries paper and still won't call it causal. Autor says AI is a crappy automation technology and a good supplement for people with judgment. Ng says the work moves up the stack and the person with the tools replaces the person without. This camp has the best track record so far because it made the fewest predictions, and it's the camp whose advice you can act on. That's also its weakness: it's a description, not a forecast, and if the accelerationists' curve is real then all of the pragmatists' career advice is a temporary bridge. I'm in this camp, with the acknowledgment that I'm in it partly because it's the one that tells me what to do on Monday.

So, has anyone's prediction clearly failed? Yes, one. Ten to twenty percent unemployment in one to five years is not on track, and its author has said as much. And has anyone's prediction clearly come true? Also one. Brynjolfsson said in 2025 that the canaries would be the young workers in exposed jobs, and the gap has widened every update since. Everything else is still on the clock.

Let's turn to what you do. This is the section people asked for.

First: own a domain. Not "be interested in" a domain. Own one. Pick an industry or a problem where a correct answer requires knowing things that aren't on the internet, and go learn those things, ideally by working in it. Healthcare workflows, insurance claims, industrial controls, legal discovery, agricultural sensing, whatever you have access to. The mechanism says implementation is cheap and domain is scarce, so the engineer who knows the domain is the one the agent can't replace and the one the forward-deployed job is looking for. If you're a junior with no domain, this is the one move with the biggest payoff, and it's the reason I'd rather see a new grad take a mediocre engineering job at a company with a real domain than a great one at a company whose product is an abstraction.

Second: own verification. Become the person on your team who can tell whether agent output is right. Concretely, that means getting good at reading diffs fast, at writing the test that would catch the bug before the bug exists, at building the eval harness for whatever your team ships, at spotting the reward-hacked test where the agent quietly asserted true. This is the skill that keeps the senior gap flat in the data. It's also learnable in months, not years, if you do it deliberately: for every agent change you review this quarter, write down what you checked and what you missed, and you'll have a private curriculum by the end.

Third: run agents fluently. The three vibe coding episodes are the syllabus for this and I'm not going to repeat them. But the career point is this: fluency is now the baseline expectation, and it's measurable in an interview in about ten minutes. Can you write a spec an agent can execute. Do you know why it's burning context. Do you have a hooks and permissions setup that keeps it from doing something stupid. Can you run three in parallel without losing track. Ng's line about the person with AI replacing the person without is about exactly this, and the METR study is the warning: you can feel fluent and be slower. So measure yourself. Time a task with and without, on real work, and see.

Fourth: ship agentic work in public. The old advice was to have a GitHub. The new advice is to have a GitHub where someone can see you directing agents to build something real, with the specs, the tests, the evals and the review trail visible. Because the thing employers can't tell from a resume anymore is whether you can actually do the job or whether you pasted a chat transcript, and the repo history of a well-run agentic project is the proof. Build a tool you actually use. Make the instruction files public. Show the eval suite. That artifact is the new portfolio, and very few candidates have one yet.

Fifth, and this is the defensive one for the group I promised: if you are trying to get your first job right now, the front door is narrower and the bar is higher, and the fix is to not look like a traditional junior. Show up with a domain and a verification habit and a public agentic project, and you're competing for the well-paid junior seats that the compensation data says still exist, rather than for the routine implementation seats that don't. Consider the roles that are hiring, which are disproportionately AI engineer and evals, and consider companies with real domains rather than the big tech front door, where new grads are seven percent of hires and falling.

And a note on the ML-specific version of positioning. If you're already an ML engineer, the moves are: get closer to production and evaluation and further from training-for-its-own-sake, because the inference and evals tiers are where headcount is. If you want the research seat, the path is still the math and the papers, but do the evals work while you wait, since it's the same muscles with a paycheck attached. And in either case, pick a domain, because "ML engineer, generalist" is the AI-era equivalent of "programmer," and you saw what the BLS projects for programmers.

Let me close with the learning path, because a few of you are at the beginning of this and the beginning is the part that changed the most.

The fundamentals did not go away. Ng put out a whole letter this summer arguing that software fundamentals are still essential in the agentic era and I agree with him, and the reason is verification: you cannot check work you don't understand. So the core curriculum of this show, Machine Learning Guide, the math, the models, the training loop, the classic algorithms, is still where I'd send you first, and it's the reason the guide episodes exist. Learn it well enough that when an agent hands you something, you know whether it's right.

Then the tools, which are this podcast's applied episodes. The vibe coding trio for running coding agents on real codebases. The agents pair for building agents and running a personal one safely. The media trio if your domain touches image, video or audio. Those aren't a replacement for the fundamentals, they're the layer on top, and the layer changes every few months, so treat them as a habit rather than a course.

Then a domain and a project, which are the two things no podcast can give you and which the whole labor market is pricing.

If you want the longer-form version of any of this, the shows Gnothi has made, on AI, on coding agents, on video generation and on running a business with agents, are all in one place at gnothi dot A I slash series.

So, the recap. The aggregate job market is fine and the bloodbath prediction failed. Entry-level hiring in exposed occupations, including software, is degraded and widening, and it's a hiring effect, not a firing effect. Software postings are a quarter below pre-pandemic with several causes stacked. The mechanism is that implementation got cheap, so specification, verification and domain got scarce, and the government's own projection shows programmers shrinking while developers and data scientists grow. ML jobs splintered into five roles and four of them are hiring. And the positioning is: own a domain, own verification, run agents fluently, ship agentic work in public, and if you're new, don't look like the old junior. That's the episode. Go build something and put the instruction files in the repo.