One Year In, the Shift Is No Longer a Prediction

March 2026

A year ago, I stood in front of a room full of founders and told them a command-line tool would change everything about how we think about building software. I showed them Claude Code. A few of them were excited. Most were polite. Some were clearly thinking I was overselling it.

Last week, one of those founders texted me. Her three-person startup just shipped a product that would have taken a team of twelve in 2023. She didn’t hire more engineers. She got better at telling agents exactly what to build.

In March 2025, I wrote that the implementation layer was dissolving. That the bottleneck was shifting from writing code to articulating what you actually want. I called it a “specification renaissance.”

I was right about the direction. I was wrong about the speed.

The Priesthood Falls (Again)

The history hasn’t changed, so I’ll keep this brief for anyone who read the original.

In 1957, IBM released FORTRAN. For the first time, programmers could write AREA = 3.14159 * RADIUS ** 2 instead of dozens of machine code instructions. John Backus, the creator, later described the culture he was challenging: a “priesthood of programming” who regarded themselves as “guardians of mysteries far too complex for ordinary mortals.”

Grace Hopper pushed compilers against resistance from people who thought automatic programming was crazy. Colleagues worried it would make programmers obsolete.

They were right to be nervous. They were wrong about the outcome. High-level languages created an explosion in demand for programmers. The skills that made you valuable as an assembly programmer became irrelevant to 99% of the work. New skills became essential.

The priests didn’t disappear. They transformed.

That same pattern is playing out right now. Except this time, we have the receipts.

From “Gradually” to “Suddenly”

In the original piece, I quoted the old line about change happening “gradually, then suddenly.” I told those founders we were in the “gradually” phase.

We’re not anymore.

In 2025, GitHub saw 43 million pull requests merged per month, a 23% increase year over year. Annual commits pushed jumped 25% to nearly one billion. Roughly 85% of developers now use AI coding tools on a regular basis, and around 46% of all code written by active developers comes from AI. Those aren’t projections. Those are actuals.

Stripe’s internal AI agents produce over 1,000 merged pull requests every week. TELUS saved more than 500,000 hours using AI-driven development across 13,000 internal solutions. Zapier hit 89% AI adoption across their entire organization. This isn’t a pilot program or a handful of early adopters running experiments. This is how software gets built now at companies that are paying attention.

A year ago I said the teams achieving 10x productivity gains were still outliers. Some of them still are. But 2x to 5x gains are now common among engineers who have figured out how to work with agents properly. The key word there is “properly,” and I’ll come back to that.

The Vibe Coding Arc

Something happened this past year that I didn’t predict, mostly because the term didn’t exist yet when I wrote the original piece.

In February 2025, Andrej Karpathy posted a tweet describing what he called “vibe coding.” You give in to the vibes, embrace the output, forget that the code even exists. It was a throwaway thought. A shower-time tweet. It became the dominant frame for AI-assisted development for an entire year.

Then people tried to ship vibe-coded software to production. Security vulnerabilities. Unmaintainable architecture. Accumulated technical debt from code nobody reviewed because nobody could read it. The industry learned a hard lesson: AI can generate code faster than any human, but speed without direction produces expensive garbage at scale.

Exactly one year after his original tweet, Karpathy posted again. This time he retired the term. In its place, he proposed “agentic engineering,” which he defined as the discipline where you’re not writing the code directly 99% of the time, you’re orchestrating agents who do, and acting as oversight. The word “engineering” was deliberate. Art, science, and professional skill. Something you can learn and get better at.

This arc, from vibe coding to agentic engineering, is exactly the transition I described in 2025 as the shift from implementation to articulation. The industry just needed a year of painful experience to validate it.

The Bottleneck Moved (Again)

Here’s what I said last year: the bottleneck shifted from implementation to articulation. The person who can clearly specify what they want now has more leverage than an entire team of developers who are fuzzy on the requirements.

That’s still true. But the bottleneck has already moved again, and it moved faster than I expected.

We now have three distinct bottlenecks that surface depending on the maturity of the team:

Specification is still the first wall most people hit. If you can’t describe what you want built with precision, agents will build you something that compiles, passes obvious tests, and solves the wrong problem. A Google Cloud PM recently shared a story about an intern who accomplished more in an afternoon with Claude Code than a senior engineer could do in three days. The difference wasn’t the tool. The intern was better at breaking down the problem into clear, verifiable subtasks.

Context is the wall that hits next. Prompt engineering was the buzzword in 2023 and 2024. In 2026, it’s been overtaken by context engineering. Anthropic published guidance on this, defining it as the discipline of curating and maintaining the optimal set of information during inference. ThoughtWorks calls it the biggest shift in developer experience this year. The idea is straightforward: the quality of an agent’s output depends less on how cleverly you phrase your request and more on what information the agent has access to when it works. Your codebase conventions, your architectural decisions, your team’s patterns, your domain constraints. If those things aren’t structured in a way agents can consume, it doesn’t matter how good the model gets.

Governance is the wall that hits at scale. When a single agent can produce a thousand PRs a week, you need automated security scanning, audit trails, quality gates, and clear ownership models. Manual code review can’t keep pace with agent-generated output. The organizations figuring this out are the ones who will scale. The ones who aren’t are building a mountain of technical debt they can’t see yet.

Context Engineering Is the New Skill

In the original article, I listed “context curation” as a becoming-essential skill. I buried it in a bullet point. That was a mistake. It deserved its own section, because it turned out to be one of the defining skill categories of 2026.

Here’s the short version. Large language models don’t learn your preferences through osmosis. They know exactly what’s in their context window and nothing else. Early on, people treated that as a limitation. Smart teams now treat it as a design surface.

Anthropic open-sourced the Agent Skills specification in late 2025. It’s been adopted by Claude Code, GitHub Copilot, Cursor, and OpenAI Codex. The idea is that instead of stuffing everything into a system prompt and hoping the agent pays attention, you structure your expertise as modular skills that get loaded on demand. Write a skill once, use it everywhere. The agent loads only what it needs for the current task, which keeps the context lean and the output consistent.

This matters because of something researchers call “context rot.” Million-token context windows sound impressive, but the transformer architecture forces every token to attend to every other token. At 4,000 tokens, that works great. At 400,000 tokens, performance degrades in predictable ways. Information in the middle gets lost. Attention spreads thin. The agent’s effective intelligence drops.

Context engineering solves this by being deliberate about what goes in. Your project’s CLAUDE.md file, your architectural rules, your team conventions, your skill definitions. These are the new artifacts that determine output quality. For platform engineers, this should feel familiar. We’ve spent careers building abstractions, writing documentation, creating self-service interfaces. Context engineering is that same work, aimed at a new consumer: the AI agent.

What Claude Code Actually Looks Like in 2026

A year ago, I described Claude Code as “an autonomous agent that can understand a problem description, break it into components, implement solutions across multiple files, run tests, fix bugs, and iterate.” That description is still technically accurate in the way that describing a car as “a box with wheels that moves” is technically accurate.

Here’s what the tool actually does now.

Claude Code runs agent teams. Not one agent working through a task sequentially, but multiple specialized agents working in parallel. You can have one agent analyzing code for reuse opportunities, another reviewing for quality issues, and a third checking for efficiency problems, all running simultaneously and reporting back. This isn’t a beta feature anymore. It shipped.

It has voice mode. You can speak your instructions instead of typing them. This sounds like a convenience feature until you realize how it changes the workflow. Describing architecture out loud, talking through constraints, explaining the problem context verbally while the agent works. Coding sessions now look less like typing at a terminal and more like directing a team.

It remembers things. Not in the way early AI tools pretended to remember by echoing back your last message, but through actual persistent memory across sessions. Architectural preferences, coding patterns, project context. The agent picks up where it left off.

It has a full 1M token context window on Opus 4.6. Skills that load on demand. Native IDE extensions for VS Code and JetBrains. Background agents that run while you do other work. A /loop command that executes recurring tasks on a schedule.

The tool I showed those founders in 2025 was a preview. What exists now is a development environment where the human’s job is to specify, direct, and verify while the agents handle execution.

Platform Engineers as Agent Architects

In the original piece, I called platform engineers “intent orchestrators.” I still like that framing, but it needs updating.

The reality in 2026 is that platform teams are becoming the people who design and maintain the systems that agents operate within. Not just infrastructure provisioning and CI/CD pipelines, but the guardrails, the quality gates, the context structures, and the governance frameworks that make agent-driven development safe at scale.

Think about it this way. When a single developer can deploy five parallel agents that each generate, test, and refine code autonomously, somebody needs to make sure those agents are working within the right constraints. Somebody needs to define what “safe self-service” looks like when the self-service consumer is an AI agent rather than a human developer. Somebody needs to build the automated security scanning that catches vulnerabilities at agent speed rather than human speed.

That somebody is the platform team.

The role isn’t less technical. If anything, it’s more technical. You need to understand how context windows work to design effective skills. You need to understand agent orchestration patterns to build useful development workflows. You need to understand security at a systems level to build governance that scales. This is the natural evolution of what platform engineering has always been, abstracting complexity and providing guardrails, but the consumer has changed.

The New Practitioners

Here’s something I didn’t cover in the original piece, and I should have.

The practitioners building with these tools are no longer limited to professional software engineers. A thoracic surgeon publicly shared that he learned to code through Claude Code, ran 67 autonomous agent sessions, and shipped a full-stack platform with a blog, analytics, and multi-agent orchestration. Not a toy app. A production system.

Product managers are building working prototypes to validate ideas before writing a single spec document. Researchers are building data analysis pipelines and frontend visualizations without waiting on engineering teams. Security teams are using agents to analyze unfamiliar codebases. Domain experts with deep knowledge of their field but no formal computer science training are building real tools that solve real problems.

This is the FORTRAN parallel playing out in real time. When compilers eliminated the need to think in machine language, the number of people who could build software exploded. The same thing is happening now. The barrier to entry hasn’t dropped to zero, you still need clear thinking, domain knowledge, and the discipline to verify outputs, but it has dropped far enough that the population of builders is expanding rapidly.

The bottleneck isn’t “can you code?” anymore. It’s “do you have taste?” Do you understand the problem well enough to know when the agent’s output is right and when it’s subtly wrong? Do you know what good looks like in your domain? Can you architect a solution before you try to build it?

The New Skill Stack (Updated)

Here’s the revised version of what I listed a year ago, adjusted for what we’ve actually learned.

Still essential, now proven: Systems thinking and architectural reasoning remain the foundation. If you can’t think about how components interact, agents will build you a collection of parts that don’t work together. Understanding tradeoffs between consistency and availability, speed and safety, simplicity and flexibility. These haven’t diminished in value at all. Domain expertise, meaning deep knowledge of the actual problem space, is more valuable than it’s ever been.

Now essential, no longer emerging: Clear written specification. Your specs are your code now, and the quality of your writing directly determines the quality of your output. Context engineering across rules, skills, memory, and project documentation. Multi-agent orchestration, understanding when to run agents in parallel versus sequentially, when to use specialized models for specific tasks, and how to coordinate handoffs between agents. Verification thinking, knowing how to validate that what the agent built actually solves your problem, not just that it compiles and passes tests.

Newly essential, barely discussed a year ago: Governance design. Building quality gates, security scanning, and audit trails that work at agent speed. Agent Skills authoring, structuring your team’s expertise as portable, reusable skill definitions that any agent can consume. Cognitive load management, being deliberate about what goes into context and what stays out, because more information doesn’t mean better results.

Diminished further than expected: Memorizing syntax and APIs was already declining. It’s now genuinely irrelevant for most work. Writing boilerplate code, generating test scaffolds, creating standard configurations. These are fully delegated tasks now. Manual code review for routine issues. Agents catch obvious problems faster than humans. The interesting review work, the architectural stuff, the subtle design implications, that’s still human territory.

What This Means for Education

I build training courses. I’ve been doing this for over twenty-five years. I’ve trained more than a million engineers through KodeKloud. And the model I’ve been using is fundamentally changing.

The old approach was: learn the syntax, practice the mechanics, build muscle memory, eventually understand the patterns. We front-loaded implementation skills because implementation was the bottleneck.

That model still produces people who can write code. It doesn’t produce people who can direct agents effectively. The gap between writing code yourself and specifying what an agent should build is real, and our training pipelines haven’t caught up.

The new model needs to front-load specification, context design, and verification. Teach people to think architecturally before they think syntactically. Teach them to write CLAUDE.md files and Agent Skills and structured constraints. Teach them to evaluate AI output critically, not just for correctness but for maintainability, security, and alignment with actual business requirements.

I’m not saying we abandon technical depth. The engineers who thrive in this environment are the ones who understand systems deeply enough to catch when an agent produces something that looks right but isn’t. But the sequence changes. Architecture first, then implementation details. Verification first, then generation. The ability to explain what you want clearly, before the ability to build it yourself.

The Cognitive Debt Problem

There’s a new failure mode that didn’t exist when I wrote the original piece. People are calling it “cognitive debt,” and it’s the accumulated cost of poorly managed AI interactions, context loss, and unreliable agent behavior over time.

Here’s how it shows up. A team adopts AI coding tools aggressively. Individual productivity metrics go up. Lines of code increase. Pull requests ship faster. But organizational delivery stays flat or actually degrades. Nobody fully understands the codebase anymore because significant portions were generated rather than written. Bugs in AI-generated code take longer to diagnose because the developer who “wrote” it doesn’t have the mental model of how it works. Knowledge that used to live in people’s heads now lives in agent context that gets lost between sessions.

This is the productivity paradox I mentioned in 2025, and it’s now well documented. The teams that avoid it are the ones who treat agent-generated code with the same rigor they’d apply to code from a new hire who’s fast but unfamiliar with the codebase. Review it. Understand it. Document why it exists. Build tests that capture the intent, not just the behavior.

Cognitive debt is what happens when you get the “vibe coding” speed without the “agentic engineering” discipline.

The Dissolution, One Year Later

Here’s the thing about layers dissolving: the layer doesn’t disappear. It becomes infrastructure. It becomes assumed. It becomes boring.

Assembly language didn’t vanish. Somewhere right now, someone is writing assembly for a device driver or a kernel module. But for 99% of programmers, it’s invisible. A layer they never touch.

In 2025, I said implementation wouldn’t vanish either. That prediction has held up. Code is still being written. It’s just increasingly written by agents operating under human direction. The layer hasn’t disappeared. It’s dropped below the line of what most practitioners need to think about directly.

What I underestimated was how fast the next layer would form on top. We’re already seeing the early signs of a world where you don’t just tell an agent what to build. You tell a team of agents, each with specialized skills, operating within governance frameworks, drawing from structured context, reporting through quality gates. The human isn’t just a specifier anymore. The human is the architect of the system that specifies.

It’s layers all the way up.

A year ago, I asked: “What are you going to build when the implementation layer dissolves?”

Some people answered that question. A surgeon built a platform. A three-person startup outshipped a team of twelve. Platform engineers became agent architects. Non-developers became builders.

The question for 2026 isn’t about whether the layer is dissolving. That’s settled. The question is whether you’re building the skills to work at the layer above it. Context engineering. Agent orchestration. Governance design. Specification as a discipline rather than an afterthought.

The implementation layer dissolved.

The orchestration layer is forming.

What are you going to build on top of it?

Michael Rishi Forrester is a Principal Training Architect and DevOps Advocate at KodeKloud, founder of The Performant Professionals, and has been preparing tomorrow’s innovators for over 25 years. He has trained more than 1 million engineers and focuses on helping technical professionals adapt through industry transformations.

Connect: @peopleforrester | linkedin.com/in/michaelrishiforrester | michaelrishiforrester.com

Tags: #AI #DevOps #PlatformEngineering #FutureOfWork #ClaudeCode #AgenticEngineering #ContextEngineering #SoftwareDevelopment #TechLeadership

We Have Never Deskilled the Mind Like This Before

And we have no idea what happens next

History has a pattern for what happens when a new technology makes a skilled trade obsolete.

The factory floor ended the artisan economy. Before mass production, a blacksmith spent years as an apprentice, learning the feel of metal under a hammer, when to quench and when to let cool, how to read the color of heated steel. That knowledge lived in hands and in bodies. It transferred slowly, person to person, across decades. It was the kind of skill that couldn’t be written down because most of it wasn’t conscious. It was accumulated..

Then came factories. A stamping machine could produce in seconds what a journeyman spent years learning to make by hand. The craft didn’t disappear overnight. But the value of craft collapsed. The apprentice pipeline dried up. Why spend seven years under a master blacksmith when a factory line would hire you on Monday?

The knowledge succession broke. And nobody really noticed until the masters were gone.

The Digital Age Reversed It. Briefly.

When computing arrived, something unusual happened: skilled craft came back.

Software engineering rebuilt the artisan economy for the knowledge age. Junior developers wrote terrible code, got their PRs destroyed in review, debugged things they didn’t understand, got paged at 2am and figured out why production was on fire. That was the apprenticeship. That was how the knowledge transferred. Not through documentation or onboarding decks. Through the doing..

A senior engineer wasn’t just someone who knew more. They were someone with scar tissue. They’d shipped the bad architecture and lived with the consequences. They’d optimized prematurely and spent six months unwinding it. They’d built the system that couldn’t scale and been the one who had to explain why. The judgment that made senior engineers valuable wasn’t knowledge. It was earned intuition, built over years in the implementation layer.

The guild model came back. Junior, mid, senior, staff, principal. A legitimate apprenticeship ladder, hidden inside job titles.

Now We’re Doing It Again

This is not the first time technology has gone after cognitive work.

In the 1940s and 50s, “computer” was a job title held by human beings, people whose entire profession was mathematical calculation. Electronic computers eliminated that profession within a generation. Spreadsheets wiped out roughly 400,000 accounting clerk positions after 1980. Word processors dissolved the typing pool. Legal databases automated the citation research that had previously consumed entire workdays for junior associates.

Technology has been replacing specific cognitive tasks for decades. This is not new.

What is new, and it matters, is the generality of what’s happening now.

Every prior wave of cognitive automation targeted a narrow function. Spreadsheets did arithmetic. Legal databases did citation lookup. Word processors handled document formatting. Each tool was a scalpel: precise, domain-specific, bounded. The humans who lost those jobs had somewhere to go, because the automation only reached so far.

An LLM doesn’t have one PhD’s worth of pattern recognition. It has the distilled output of essentially every PhD who ever published, every Stack Overflow thread ever written, every codebase ever committed to a public repository. It writes code, drafts documents, analyzes architecture, explains tradeoffs, and reviews pull requests, not in one narrow lane but across all of them at once. This is a different kind of tool. Not a scalpel. Something more like a general solvent.

The implementation layer is going the way of the stamping machine. Not gone, but no longer where the value lives. No longer where you invest years of human time.

And here’s where the collective mythology kicks in: the engineers who already have deep systems knowledge are not threatened by this. They’re multiplied by it. The business case for hiring senior talent has never been stronger.

True enough. But it leaves something out.

The Problem Is Where Elite Engineers Come From

The multiplier narrative has a data problem.

METR, an AI safety research organization, ran a randomized controlled trial in mid-2025 with 16 experienced open-source developers and 246 real-world tasks. They found that AI tools made experienced developers 19% slower, not faster. The developers predicted a 24% speedup. They still believed AI had helped them. They were wrong. A separate field experiment by MIT, Microsoft, and Accenture, covering roughly 1,974 developers, found that junior developers gained 27–39% productivity from AI assistance while senior developers gained only 8–13%.

The “100x engineer” is largely an aspiration right now. The truth is context-dependent: seniors use AI better for architectural decisions; juniors benefit more on implementation tasks. Neither group gets a clean multiplier.

But set the productivity debate aside. The harder problem runs deeper.

Every senior engineer working today built their judgment in the implementation layer. They got there by being junior, then mid, then senior. They wrote the code. They owned the bugs. They did the work that AI is now going to do.

The hiring signal is already visible. A Stanford and ADP payroll study published in August 2025, covering millions of workers, found that employment for software developers aged 22–25 had dropped roughly 20% from its late-2022 peak, while workers aged 30 and up in the same AI-exposed fields saw employment grow. A Harvard study that same year, examining 285,000 firms and 62 million workers, found that companies adopting generative AI saw junior employment drop roughly 9–10% within six quarters. SignalFire reported a 50% decline in new role starts by people with less than a year of post-graduate experience at major tech firms between 2019 and 2024.

To be fair: post-pandemic correction, rising interest rates, and reduced venture capital are all real factors here. The Stanford study’s authors themselves noted they make no claim that AI is the sole cause. This is a multi-causal decline, not a clean AI story.

But some of it is clearly AI. Salesforce announced it would hire no new software engineers in 2025. Shopify’s CEO issued a memo requiring teams to prove AI can’t do a job before asking for headcount. The rationale in each case is the same: why grow the junior headcount when AI can absorb implementation work?

The economics are obvious. Each decision makes complete sense for the organization making it.

But organizations don’t exist in isolation. Industries do. And the industry is collectively making the same rational decision, which means the industry is collectively eliminating the environment where the next generation of senior engineers gets built.

Sociologists call this a tragedy of the commons. Labor economists would recognize it from Harry Braverman’s Labor and Monopoly Capital (1974), the foundational work on deskilling, which documented how industrial capitalism systematically separated the conception of work from its execution, concentrating judgment at the top and eliminating it from the bottom. The Communications of the ACM published a feature in 2025 explicitly applying Braverman’s framework to AI. Cal Newport invoked Braverman by name in January 2026 when warning about AI-driven deskilling. When Anthropic’s own January 2026 Economic Index report used “deskilling” as an analytical category to describe Claude’s effect on occupations, the concept went from academic framing to industry description.

The Compounding Problem Nobody Is Naming

There’s a term now circulating in research circles: never-skilling.

Not deskilling, where you had a skill and lost it. Never-skilling is what happens to the generation that enters the workforce after the training-pipeline tasks are already gone. They don’t lose a skill. They never develop it in the first place, because the work that would have built it is being handled by agents, reviewed by elites who are the last people to have gone through the full crucible.

The junior developers who do get hired today aren’t writing code from scratch and fixing their mistakes. They’re reviewing AI output. Catching the errors that surface. Learning, in some degree, to recognize what wrong looks like from the outside.

Nobody knows whether that builds the same quality of judgment. Ask any experienced engineer whether reading about concurrency bugs is the same as having caused one. Ask whether reviewing AI-generated infrastructure code teaches you the same things as being the one paged at 3am when that infrastructure fails.

Carnegie Mellon researcher Aniket Kittur has warned that AI is producing a loss of basic knowledge among engineers who rely on it without engaging with it. Matt Beane at UC Santa Barbara has spent years studying how AI tools disrupt the apprenticeship dynamics through which expertise actually transfers. Microsoft’s CTO Mark Russinovich and Scott Hanselman published a piece in the Communications of the ACM in February 2026 proposing a new preceptor-based training model for engineering, explicitly because the traditional path is breaking down. They called the knowledge succession concern “a hot topic” in conversations with customers.

IBM announced in February 2026 that it would triple its entry-level hiring. AWS CEO Matt Garman called the idea of replacing all juniors with AI “one of the dumbest things I’ve ever heard.” These are the loudest institutional counter-signals to the prevailing tide. Whether they shift anything at the industry level, or whether they’re outliers in a race to the bottom, is an open question.

The Question Nobody Is Asking

The conversation about AI and the future of work is almost entirely about the workers who exist today. Will senior engineers be replaced? Will mid-level roles survive? What do engineers need to learn to stay relevant?

These are real questions. But they’re not the most important question.

The most important question is about the workers who don’t exist yet.

The twelve-year-old who wants to build things. The computer science student learning to code in a world where AI writes most of the code. The career changer who wants to enter tech but finds the entry-level pipeline largely automated away. What is their path to senior? What replaces the decade of implementation work that built every senior engineer working today?

Researchers at Stanford, Carnegie Mellon, and UC Santa Barbara are asking this. Microsoft is asking it. IBM is acting on it. But there is no policy framework, no industry-wide response, no coordinated effort. Just individual companies making the rational short-term call, and a handful of voices warning that the aggregate result of those individual calls will be visible, and costly, in about fifteen years.

That’s how knowledge succession failures always work. They’re invisible until the last master retires.

What History Actually Teaches Us

When electronic computers displaced human computers in the 1940s and 50s, most of the displaced workers were still alive to retrain. When spreadsheets restructured accounting, the profession adapted: roughly 400,000 clerk positions gone, but about 600,000 new accountant roles created. The cognitive work didn’t vanish; it moved up the abstraction ladder.

Maybe that pattern holds here. Maybe the junior engineers who can’t find traditional entry-level implementation roles find work as AI supervisors, output reviewers, and systems monitors, accumulating in that work a different but equivalent kind of judgment.

Maybe. But the analogy that should worry people more is what happened to physical trades after the industrial revolution. The trades didn’t die. They contracted, specialized, and became luxury. The knowledge largely survived. But the pipeline that had once produced thousands of journeymen per generation now produces dozens. The craft is preserved as heritage, not as infrastructure.

If software implementation follows the same path, preserved by the people who love it and handled at scale by agents, the question is whether the pipeline that produces the elites who oversee those agents can sustain itself on craft-scale volume.

The industries that navigated these transitions without catastrophic knowledge loss did so because they made deliberate choices. They built institutions. Trade programs, certification bodies, structured apprenticeships. Things that kept the transfer pipeline alive even when the economics of the moment argued against it. They recognized that the market would not solve this on its own, because the market’s time horizon is a quarterly report and the knowledge succession problem plays out over fifteen years.

Software engineering as an industry has never had to make this choice before. The technology never moved fast enough to outpace the apprenticeship pipeline.

Now it might. And the window for deliberate choices is open right now, while the people who hold the knowledge are still working.

Michael Rishi Forrester has spent 25 years training engineers through platform shifts, from Red Hat to ThoughtWorks to AWS to cloud-native to AI. He’s a Principal Training Architect at KodeKloud, founder of The Performant Professionals, and has watched more “this changes everything” moments than he can count. He’s not sure this one is different. He’s not sure it isn’t.

Bluesky | Mastodon | Hachyderm | LinkedIn | YouTube | X

Tags: #FutureOfWork #AI #SoftwareEngineering #TechLeadership #AIStrategy #EngineeringCulture #GenerativeAI

By Michael Rishi Forrester | March 2026

Two things happened this week that I can’t stop thinking about.

The Bureau of Labor Statistics dropped the February 2026 jobs report. The economy shed 92,000 jobs. Unemployment held at 4.4%. The headlines did what headlines do: political takes, macro hand-wringing, the usual noise.

The same week, Anthropic published a research paper, Labor Market Impacts of AI: A New Measure and Early Evidence by Maxim Massenkoff and Peter McCrory. It’s one of the more honest pieces of AI labor economics I’ve come across, because it doesn’t try to tell you what AI could do. It looks at what AI is actually doing in real workplaces right now.

Read together, these two data points tell a story the main narrative is completely missing.

Not a Firing Wave. A Hiring Freeze.

The Anthropic paper introduces what they call Observed Exposure, which measures the difference between what AI is theoretically capable of and what people are actually using it for in professional contexts today.

That gap is enormous. Computer and math occupations are theoretically 94% exposed to AI displacement. The actual observed coverage sits around 33%. Real deployment is running at roughly one-third of theoretical capability.

That’s not a reason to exhale. It’s a countdown.

The part that got the least attention: young workers aged 22 to 25 are entering AI-exposed occupations at a rate roughly 14% lower than they were in 2022. Companies are not laying off experienced analysts, customer service leads, or junior engineers in mass. They’re quietly not replacing them when they leave, and they’re not hiring the next cohort into those roles.

That’s the pattern. Not a dramatic collapse, just a slow drain.

Entry-level roles aren’t disappearing in a flash. They’re evaporating through attrition. A position opens, leadership pauses and asks whether an AI workflow can absorb it, then decides to wait. Three months later it’s not in the budget. Six months after that, nobody remembers what that person was even doing.

The Person Nobody Is Worried About

The public conversation about AI and jobs is almost entirely wrong about who is most at risk.

The Anthropic research found that the most AI-exposed workers tend to be female, older, more educated, and higher-paid. The ten most exposed occupations include computer programmers, customer service representatives, market research analysts, financial and investment analysts, and software QA testers.

This is not the warehouse worker automation story we’ve been rehearsing for a decade. The person most at risk right now is a knowledge worker in their 40s with a graduate degree doing information-dense work in an office. That’s a completely different economic and social problem than the one most policy conversations are preparing for.

What Actually Worries Me

I’ve spent 25 years watching large workforces try to adapt to major technology shifts. DevOps. Cloud migration. Kubernetes. Each time, there’s a recognizable pattern: the technology arrives faster than the organizational capacity to absorb it, and a cohort of people gets left behind not because they were bad at their jobs but because nobody built the bridge in time.

AI is moving faster than any of those prior shifts. And unlike those prior shifts, it doesn’t just change the tools. It changes what produces value in the first place.

What keeps me up isn’t the workers being displaced today. It’s the 22-year-old who enrolled in a CS program in 2022 because software engineering was the safest career bet, and is now graduating into a market that quietly stopped hiring for entry-level software roles while they were in school. That person has no runway. They haven’t had time to build the tacit knowledge, the judgment, and the pattern recognition that still makes experienced workers valuable.

Dario Amodei has said publicly that AI could eliminate 50% of entry-level white-collar jobs within 1 to 5 years. The Stanford/ADP payroll data already shows a 13% decline in entry-level hiring in AI-exposed occupations since 2022. These aren’t predictions anymore. They’re early data points.

Nobody Has This Figured Out

Something that gets glossed over in almost every AI and workforce conversation: nobody actually knows how to do this yet.

The frontier models are outperforming expectations faster than most enterprise transformation programs can keep up with. Organizations are genuinely trying to build the plane while it’s in the air. The companies claiming they have a mature AI transformation playbook are, in most cases, slightly ahead of their clients on a learning curve that everyone is still climbing.

That isn’t pessimism. It’s just accurate. And acknowledging it is more useful than pretending a clean methodology exists.

What I do know from watching a million engineers work through technology transitions is that the human and organizational side is always the hard part. The resistance isn’t technical. It’s psychological, cultural, and political. It shows up as the subject matter expert who feels threatened, the middle manager whose value was knowing things a language model now knows, the team that agrees AI is important in the all-hands meeting and then quietly changes nothing about how they work.

Those problems don’t have a technical solution. They require honest organizational leadership, genuine investment in people, and the willingness to tell the truth about what’s changing rather than managing perceptions.

The Deployment Gap Is Closing

The most important finding in the Anthropic paper is that gap between theoretical capability and actual deployment. AI is covering about a third of what it theoretically could right now. That gap closes as models improve and adoption spreads.

Organizations have a window because of it. Not a comfortable one, but a real one. The question is whether they use that time to build genuine AI-ready workforces, not checkbox training programs or a two-hour intro to ChatGPT, but real capability development that helps people understand how to work alongside these systems, what judgment still belongs to humans, and how to stay valuable as the automation frontier moves.

The young worker hiring signal is where I think the real crisis is forming. If companies quietly stop backfilling entry-level roles, we end up with a generation that never got the foundational reps. In five years there won’t be a shortage of AI tools. There will be a shortage of mid-career practitioners who have the contextual judgment to use those tools well, because we never built the pipeline that creates them.

What I’m Watching

Mass displacement hasn’t happened yet, and the Anthropic researchers are careful to say the early entry-level hiring signal is barely statistically significant with alternative explanations still on the table.

But the underlying trends are directional. Long-term unemployment is up 27% year-over-year. The information sector is contracting steadily. 330,000 federal knowledge workers are entering a job market already slowing in knowledge-role hiring. Entry-level positions in AI-exposed fields are quietly shrinking for workers in their early 20s.

Put that next to a technology currently deployed at one-third of its theoretical ceiling and still accelerating, and the shape of what’s coming starts to come into focus.

Organizations that wait until the signal is impossible to ignore will find the runway is a lot shorter than it looks today.

P.S. If you are not reading KP Reddy who, he and I must have had the same thoughts at the same time… I highly recommend. substack.com/@insights… I found his article after I wrote mine and was shocked about how we came to similar conclusions.

Sources: Anthropic, “Labor Market Impacts of AI: A New Measure and Early Evidence” (Massenkoff & McCrory, March 5, 2026). U.S. Bureau of Labor Statistics, February 2026 Employment Situation (March 6, 2026). KP Reddy, “The Jobs Report Just Told You Something the AI Debate Won’t,” Substack (March 6, 2026).

AI Is Replacing 80% of Coding. These Are the Skills That Will Still Matter.

AI has replaced roughly 80% of what we traditionally called “coding skills.” It will keep replacing more. A handful of capabilities remain human. I’m not panicking, but I am paying attention.

According to Harness’s 2025 State of AI in Software Engineering report, 72% of organizations have experienced at least one production incident directly caused by AI-generated code. AI writes code faster than any human ever could. It also breaks things faster than any human ever could.

I’m writing more code now than I have in the past twenty years. When I say “writing,” I mean guiding the process, shepherding syntax, reviewing output. The actual generation isn’t me anymore.

This November marks 30 years in infrastructure, operations, DevOps, and platform engineering. Red Hat. ThoughtWorks. AWS. KodeKloud. I’ve watched every “this will replace engineers” wave come and go. Mainframes to client-server. Waterfall to Agile. On-prem to cloud. VMs to Kubernetes. Internal developer platforms to platform engineering.

Each transition killed certain tasks while making others more valuable. AI-assisted coding follows the same pattern. The code is being automated. The engineering is not.

Some lower-level engineering skills are disappearing. Some design decisions that once required years of experience are now handled by AI in seconds. But there are capabilities that AI genuinely cannot replicate. These are worth mastering now because they’re becoming scarcer.

Human Connection

The most critical moments in any engineering organization aren’t technical. They’re human. The production incident where someone needs to make the call to roll back or push forward. The architecture review where senior engineers have incompatible visions. The retrospective where a team needs to acknowledge failure without assigning blame, where you’re either building a culture of safety or a culture of fear.

I’ve trained hundreds of engineers across multiple organizations. The ones who become truly senior aren’t distinguished by their technical knowledge. Technical knowledge can be acquired. They’re distinguished by their ability to build trust, navigate conflict, create psychological safety, and communicate under pressure.

AI can answer technical questions. It cannot sit with a junior developer who just caused their first production incident and help them process the experience without shame. It can’t read the exhaustion or worry in a team standup. It can’t advocate for sustainable pace based on nonverbal cues it will never perceive.

Engineering is a team sport. The human skills are the sport itself.

Legal and Ethical Accountability

AI cannot be sued. You can.

If you blindly accept AI-generated code and it causes a data breach, you’re liable. If AI hallucinates a GPL-licensed snippet into your proprietary codebase, you’re liable. If an AI-generated algorithm introduces bias that harms users, you’re liable. Engineers are the accountability shield between AI capabilities and organizational risk.

I’m not talking about paranoia. AI operates without consequences. Humans operate within systems of professional responsibility, legal liability, and ethical obligation. That’s just reality.

When I review AI-generated code, I’m not just checking for bugs. I’m checking for license compliance, security vulnerabilities, privacy implications, and alignment with documented architecture decisions. The AI may not know we’re in a regulated industry with specific audit requirements. It may not be aware of institutional dependencies that matter to how the codebase actually functions.

Can we provide that context to AI? Yes, and we should. But accountability requires understanding consequences at a strategic level. AI generates outputs. Humans own outcomes.

Strategic Systems Thinking

AI optimizes for today. Good systems designers think about evolutionary architectures. Who maintains 10,000 AI-generated test cases when the schema changes?

Hopefully AI. But just because we can do something fast and repetitively doesn’t mean we should.

I see teams falling into this trap constantly. AI generates tests faster than humans can read them. Teams generate thousands of tests, achieve 95% coverage, declare victory. Six months later, they’re modifying 400 tests because the codebase changed. Will AI handle that maintenance? Probably. But is that approach strategically sound? Is testing being thoughtfully applied, or just blindly applied because we now have the capability?

Strategic thinking asks uncomfortable questions:

• How do we audit code produced faster than it can be reviewed?
• What’s our plan when the model we depend on gets deprecated or changes behavior?
• Who owns the technical debt that AI generates at scale?
• What happens when the engineer who understands the AI-generated codebase leaves?

AI is an incredible force multiplier for producing artifacts. It has no concept of maintaining them. Every line of code, human or AI-generated, is a liability that someone will have to understand, modify, and debug for years to come.

Velocity without sustainability is just faster accumulation of technical debt.

Translating Business Needs

When a stakeholder says “make it faster,” AI starts coding. A human asks: “How much are you willing to pay for that speed?”

That’s what architects do. They translate business needs into technical reality while surfacing the tradeoffs. When someone says they want 100% uptime, the architect asks what that means, what it costs, and what it implies for security and operations. When someone wants more resilience, the architect might respond: “That’s a million-dollar DR plan. Here’s what you get for that investment.”

“Make it faster” could mean any number of things:

• Our competitor launched a faster product and I’m panicking
• One customer complained and they happen to be loud
• I don’t understand why this takes time and I need education, not optimization
• We’re actually willing to spend $500,000 on infrastructure to shave off 200 milliseconds

AI cannot read the room. It can’t notice that the stakeholder’s real concern is job security, not system performance. It can’t recognize when the correct answer is “your current speed is actually fine, here’s the data” rather than immediately jumping to implementation.

Requirements translation is a human skill because it requires understanding human motivations, organizational politics, and the difference between stated preferences and revealed preferences. AI takes the ticket at face value. The engineer investigates what’s actually being asked.

Can we teach AI to do this? Yes. But the subtleties here will likely remain in the human domain for years.

Understanding Legacy Code

AI sees messy code and wants to refactor it. A human engineer knows that messy code has survived for a reason.

That function with 47 parameters and a comment that says “DO NOT TOUCH - see incident #4521”? AI wants to clean it up. The senior engineer knows that function handles an edge case that only appears under specific conditions. Maybe a particular customer in Japan submitting an order at exactly midnight UTC.

Legacy code is an archaeological record. Every production incident, every business pivot, every 3am hotfix that kept the company alive. The mess isn’t incompetence. It’s institutional memory encoded in syntax.

AI-assisted refactors can reintroduce bugs that were fixed a decade ago. The original fix was ugly, and AI optimizes for elegance. But the original developers weren’t writing ugly code. They were writing defensive code against threats the AI has never encountered.

Understanding legacy systems requires humility. It requires asking “why is this here?” before asking “how do I fix this?” AI only knows how to ask the second question. We still need humans for the first.

Architectural Reasoning

AI suggests textbook solutions. It doesn’t know about hidden constraints, regulatory requirements, political landscapes, or someone’s inexplicable preference for Redis over Memcached.

When you ask AI to design a system, it gives you the Stack Overflow consensus answer. It doesn’t know that your CTO has a vendetta against MongoDB from a previous job. It doesn’t know that your compliance team will reject anything storing data outside your home region. It doesn’t know that the “obviously correct” microservices architecture will get blocked because your ops team has three people and they’re already drowning.

Architecture isn’t about knowing the best solution. It’s about knowing the best viable solution. The one that accounts for organizational capacity, team skills, budget constraints, and the political capital required to actually ship it.

I’ve watched AI suggest Kubernetes deployments to teams that can barely manage a single EC2 instance. Technically correct. Organizationally catastrophic.

The architect’s job isn’t to find the optimal solution in a vacuum. It’s to find the optimal solution in your vacuum, with all its dust, debris, and hidden obstacles.

What To Do About It

If you’re an engineer watching AI transform your field, stop competing with AI at code generation. You’ll lose that race, and it’s not a race worth winning.

Instead, invest in the skills that make code generation valuable. Build trust. Understand accountability. Think strategically. Translate business needs. Respect legacy systems. Reason about architecture in context.

The engineers who thrive won’t be the ones who can prompt the best code. They’ll be the ones who can take that code and turn it into reliable, maintainable systems that actually serve human needs.

The code is being automated. The engineering never will be.

Michael Rishi Forrester is a Principal Training Architect at KodeKloud and founder of The Performant Professionals. November 2026 marks 30 years in infrastructure, operations, and DevOps. His focus: preparing tomorrow’s innovators while elevating the average.