In April 2024 I was a marketing analyst at a mid-sized SaaS company, building dashboards in Looker and writing the kind of SQL that gets the job done but never wins any beauty contests. By Q4 2025 I was running an "AI-native developer" role at a Series B startup, no CS degree, no bootcamp, no formal training. Vibe coding careers, it turns out, don't follow the old script. My title fits on a business card but not on my mom's mental model of what I do for a living.
My first day's standup, an old-school senior engineer with a Vim sticker on his laptop asked me, very politely, "Where did you go to school?"
I said, "I didn't. I learned to direct."
The room went quiet for a beat. Then someone laughed, and someone else said, "Okay, show us the dashboard." I shared my screen. The dashboard had been spec'd, built, and deployed by me and Claude Code over the previous weekend. It had auth, it had tests, it had a queue worker. Was it perfect? Of course not. Did it ship? It did.
That's the story I want to tell about vibe coding careers in 2026. Not the panicked "AI will replace us all" version, not the salesy "anyone can be a developer overnight" version, but the actual one I'm living, with all the weird edges and unfinished thoughts.
The honest career question
Look, the fear is real. GitHub said in late 2025 that around 30% of code on its platform is now AI-assisted, and the share is climbing every quarter. That number alone makes a lot of people want to update their resume to "barista, available immediately."
But here's what's strange: job postings for "software engineer" actually rose roughly 7% year over year in 2025, according to the trend reports out of Indeed and LinkedIn. Read that twice. The category that's supposedly being eaten by AI is growing. (See, for context, the Stack Overflow developer ecosystem reports and the LinkedIn workforce snapshots they reference each quarter.)
What's growing fastest is not "junior frontend developer who just learned React." It's titles that didn't exist three years ago: "AI-native developer," "AI engineer," "agent ops lead," "applied AI engineer," "skill curator." What's shrinking, according to the same data, is the bottom rung of the old ladder. Junior dev with no AI experience, generalist full-stack person who can't ship a Claude Code workflow, the kind of role that used to be a feeder for Big Tech grad programs. Those roles aren't dying overnight. They're just slowly losing their gravity.
This is a skill mix shift, not a vanishing act. And it's the kind of shift that rewards people who pay attention right now.
What the data actually shows
I want to do this in prose, the way Evan Armstrong used to do napkin math before he left to start The Leverage, because I find spreadsheets emotionally distancing and I don't want you to skim past the actual numbers.
US median developer salary in 2025: about $135,000. In 2024 it was around $128,000. So the median is still up. The platform isn't sinking, even if some of the deck chairs are sliding around.
The top decile is the part that's worth staring at. In 2024, top-decile dev compensation in the US was around $220,000 all-in. By late 2025 that had stretched to about $300,000 plus, and at AI-forward companies it's higher again. People who can run agent fleets, ship production systems with AI assistance, and review what comes out of those systems are pulling in compensation that used to be reserved for staff and principal engineers at the absolute top of the market.
The bottom quartile is the painful part. Stagnant or down slightly. Anecdotally, friends of mine who graduated CS in 2024 and refused to touch AI tooling are still job hunting. Friends who graduated the same year and built something publicly with Claude Code or Cursor are mostly employed, often at higher bands than their cohort.
The middle is hollowing out, the way it does in every industrial transition. Karpathy himself has argued that what we call "vibe coding" is already evolving into something more structured, which only accelerates the split. The high end stretches up, the low end stagnates, and the people in the middle either move up by adopting the new tools or drift down by ignoring them. That's not a tech story. That's an every transition in the history of work story. (For a longer treatment of this dynamic across industries, Ben Thompson at Stratechery has been writing about labor market splits in AI-era companies for a few years now, and his framing is the one I keep coming back to.)
If you'd like a deeper definition of what "vibe coding" actually is, the term that's quietly remade an entire profession in eighteen months, our intro guide walks through it. The short version is: directing AI agents to build software instead of writing every line yourself. The long version is the rest of this essay.
The new job categories that didn't exist in 2023
Here are the actual titles I see on job boards every week, with what they actually mean once you cut through the recruiter speak:
AI-Native Developer. Builds with Claude Code or Cursor as the primary IDE. Ships features five times faster than a comparable non-AI dev, sometimes more on greenfield work, sometimes less on legacy. Often comes from a non-traditional background, marketing analyst, designer, ex-PM, ex-data scientist, ex-teacher. The defining trait is fluency in direction, not in syntax. The defining failure mode is shipping confident slop. The defining strength, when it works, is moving from idea to deployed product in days instead of months.
Agent Ops Engineer. Maintains fleets of agents in production. Monitors hallucination rates, tunes prompts at scale, runs evals, builds the dashboards that tell you when an agent regressed after a model upgrade. Our agentic engineering guide goes deep on what this discipline actually looks like day to day. This is the SRE role of the AI era. It barely existed in 2023. It now pays like senior infra used to pay.
Skill Curator. Internal librarian for the company's reusable agent skills, prompts, workflows, and tools. Thinks about what to standardize, what to leave bespoke, what to deprecate. If your company has more than ten developers using AI agents, you need one of these or you'll end up with the same prompt rewritten thirty different ways across the codebase.
AI Code Review Lead. Senior engineer who specs how AI agents should review pull requests. Calibrates confidence thresholds, decides when an agent reviewer should auto-approve versus flag for human review, owns the false-positive and false-negative rates. This is judgment work, full stop. It's also the role that makes the rest of the agent stack trustworthy.
Hooks and Workflow Engineer. Builds the CI/CD around agentic systems. Pre-commit checks, post-tool-use formatters, automated PR triage, agent-to-agent handoffs. Lives in YAML and shell scripts and is deeply important even though no one tweets about them.
These are the roles. They're the ones I see hiring posts for. They're the ones my friends are getting recruited into. They're the ones the bottom-quartile salary stagnation is not affecting.
Chen here: I've hired 18 people for these roles since 2024
Sofia handed me the keyboard for this section because the patterns are easier to see when you're on the hiring side. I'm an engineering manager at a fintech, and I've personally hired eighteen people across the new categories Sofia just described. Here's what I've actually learned, with the rough edges left in.
The best hires I've made were often not from CS backgrounds. Ex-PMs, ex-data scientists, ex-marketing analysts (hi Sofia), one ex-teacher who turned out to be the most rigorous communicator on my team. The pattern is they were already used to writing precise specifications for other humans, which translated frighteningly well to writing precise specifications for agents. They didn't have the muscle memory of "I'll just write it myself" to fight against. They were already direction-native.
The worst hires I've made were senior engineers who refused to use AI seriously. Not the ones who were skeptical, skepticism is healthy and often correct, but the ones who treated AI tooling as beneath them. Two of them quit within a quarter. Three more I had to move out of agent-adjacent work. Their critique of agent output was often correct, by the way. They could spot the hallucinations and the bad architectural choices. But they couldn't or wouldn't translate that critique into better direction, which made them very expensive code reviewers and not much else.
The unexpected pattern I didn't predict: ex-PMs and ex-data scientists do unusually well in agent ops and AI-native developer roles. PMs because they've spent their careers writing specs that other people have to interpret. Data scientists because they're already comfortable with probabilistic systems where the right answer isn't always the same answer twice.
Salary range I've personally paid in the last 18 months: $95,000 for an entry-level AI-native developer (no degree, strong public portfolio, three months of intense Claude Code use), all the way up to $310,000 for a senior agent ops lead with five years of distributed systems experience plus a year of running production agent fleets. That spread is wider than what I was paying for traditional engineering roles two years ago, and the high end keeps drifting up.
My favorite interview question, the one that actually filters: "Walk me through how you'd direct an agent to refactor a 50,000-line legacy codebase. What would you watch for? What's your rollback plan? How would you know when to stop?"
The candidates who say "I'd just point Claude Code at it" fail. The candidates who say "I wouldn't, I'd do it myself" also fail, but for the opposite reason. The candidates who pass talk about chunking the work, writing characterization tests first, having the agent propose a migration plan and then critiquing that plan, running the changes through staging with traffic mirroring, and knowing the specific signals that mean "stop and re-think." They talk about cost, time, blast radius, and the human review steps they'd insert. That's the role. That's the job.
If you want a sense of what direction-fluency looks like in practice, our 50 Claude Code tips piece is basically a tactical playbook of the muscle memory I'm hiring for. People who internalize that kind of workflow are the ones I make offers to.
Okay, I'm handing the keyboard back to Sofia.
The skills that survive
Sofia again. Chen made me sound more diplomatic than I actually am, but the patterns he described match what I see from the inside. So what skills actually carry forward into this new shape of the profession?
Code reading. This one always wins. Even when you don't write code, you have to read what the agent wrote, understand whether it's right, and notice the subtle things that aren't. Reading code is harder than writing it. It rewards everything you'd read it for: structure, naming, edge cases, what's missing. The people I see thrive in agent-driven work are voracious code readers.
Spec writing. This used to be optional, the thing PMs did badly and engineers ignored. Now it's the core skill. A great spec is the difference between an agent shipping the right feature in twenty minutes and the wrong feature in two hours. Specs are now executable artifacts, not bureaucratic theater.
Systems thinking. Matters more, not less. When you're orchestrating agents that touch databases, queues, APIs, and user-facing components, you need to be able to hold the whole shape of the system in your head. Agents are great at local optimization. They are mediocre at global coherence. You bring the global view.
Communication. Always was the most underrated developer skill. Now it's load-bearing. You're communicating with humans about what you're going to ship, with agents about what to build, and with future humans (and future agents) through the artifacts you leave behind. Writing well is a developer skill now in a way it wasn't a decade ago.
Debugging at the system level. You're debugging agent behavior now, not just code. Why did the agent take three turns to find the bug instead of one? Why did it ignore the test that was clearly failing? What in the prompt or the context is causing the regression? That's a new kind of detective work, and it's fascinating.
The skills that don't transfer well
This is the part nobody likes to hear, but the data is clear and so is my lived experience.
Memorization of framework APIs. Agents memorize APIs in microseconds. Your edge there is gone, and it's gone forever. If your value was "I know every React hook by heart," that value has evaporated.
Speed-typing. Used to be a flex. Now the bottleneck has moved upstream of the keyboard. The fastest typist on my team is also the slowest shipper, because they keep typing things that an agent would have written in two seconds while they were still mid-sentence.
Knowing one language deeply but no others. The polyglot wins now. Agents make context-switching cheap, so the person who understands four languages well enough to direct an agent in any of them dominates the person who only knows Python. The one-trick specialist is in trouble.
Pure individual contribution without collaboration skills. The lone-wolf 10x engineer myth is well and truly dead. You don't ship alone anymore, you ship with a fleet of agents and a team of humans, and if you can't communicate clearly across both you'll be left behind.
Resistance to new tooling. This one I want to be gentle about because I have friends who are sliding into it and I love them. But there is no graceful version of "I don't use AI tools." Not in 2026. Not in this profession.
What this means if you're early career
If you're reading this and you're a student, a recent grad, a career changer (hi, that was me eighteen months ago), here's the honest version of what to do.
You don't need a CS degree. You do need to think clearly. The two are not the same thing, though sometimes they overlap. A philosophy major who can write a precise spec will outperform a CS grad who can't, every time.
Build things publicly. Start with the Claude Code tutorial for beginners if you have never used an agent-driven workflow before. Vibe coded portfolios are now the resume. A GitHub with five real projects you shipped, with good READMEs and a deploy link, is worth more than three internships at companies nobody will let you talk about. Show your work. Show your direction process. Recruiters now look at your prompt history the way they used to look at your commit history.
Learn one classical thing deeply. Pick data structures, distributed systems, security, type theory, whatever calls to you, and learn it for real. You need ground truth to evaluate what agents produce. Without it you're just trusting confident output, which is how slop gets shipped to production. Our piece on the gap between coding and shipping gets at this exact tension.
Get good at describing what you want. This is a writing skill. Read good writers. Practice writing specs for software you wish existed. Practice writing the reasons behind your specs, not just the requirements. The "why" is what makes an agent succeed when the prompt is ambiguous.
Get a job at a company that's already using AI agents seriously. Not one that "is exploring AI." One that ships AI-assisted features every week. The compounding learning is enormous. A year at one of those companies is worth three years at a place that's still arguing about whether to allow Copilot.
What this means if you're mid or senior
The harder conversation. The one I have with friends in their late thirties and forties who are watching the ground shift.
Use the tools or get left behind. There is no third option. I wish there was. There isn't. Our vibe coding best practices piece distills the 15 rules that separate effective agent-directed work from expensive wheel-spinning.
Your value is now in judgment, not throughput. The good news is judgment compounds with experience. The bad news is judgment without speed is no longer enough. You have to bring both, the deep pattern recognition you've spent fifteen years developing and the willingness to translate it into agent direction.
Mentor the AI-natives. They will teach you direction, the muscle memory of working with agents fluently. You will teach them rigor, the things that go wrong in production, the stories from the outage at 3 AM, the architectural intuitions you can't quite articulate but always turn out to be right. This trade is real and it's happening on every team I know.
The "10x engineer" of 2026 is the one who runs ten well-tuned agents. Maybe it's eight. Maybe it's twenty. The point is that individual contribution now means individual orchestration. The unit of work is shifting from "lines of code I personally typed" to "outcomes I personally directed." That's a profound mental shift and it's harder for senior people to make than for early-career people because senior people built their identity around the old definition.
Don't be the engineer who insists on writing every line. I have watched this be the single biggest career-limiting move of the last two years. You can be the rigorous voice, the architectural thinker, the person who calls out the bad agent output. That's valuable. But you can't refuse to use the new tools and expect to keep your seat.
This is no different from the carpenter who refused to use power tools in 1965. The craftsmanship was real. The career arc was short. There's a guitar shop near where I live where the owner still uses hand planes for everything because that's his craft, and he's incredible, and he makes maybe one guitar a year and sells it for $40,000 to a collector. That's a beautiful life and it's not a scalable career. Same shape here.
What we don't know
This is the section both of us insisted on, because we're not in the business of pretending we have it figured out.
Whether this stabilizes or keeps accelerating. The current pace of capability gains is genuinely uncomfortable, even for people inside the industry. The METR productivity study found that experienced developers were actually slower with AI on familiar codebases, which suggests the plateau question is more nuanced than "up and to the right." We don't know if it plateaus in 2026, in 2028, or never.
Whether the salary stretch continues or compresses. Right now the top decile is pulling away from the median. That could keep going (more bifurcation), or the median could catch up as the tooling commoditizes. We genuinely don't know which. Bet on both being possible.
Whether AI-native roles get formalized into degrees and certifications, or stay informal craft traditions. Universities are scrambling to add programs. Bootcamps have pivoted hard. None of them are obviously winning yet. The best AI-native developers I know learned the way Sofia did, which is to say, by doing it, which is to say, the same way good developers have always learned.
Whether the next downturn hits AI-natives harder or easier than traditional devs. There's a case for "easier" (they're the productivity multiplier, you keep them and cut middle layers). There's a case for "harder" (they're the new role, no track record, easier to cut). I can construct both stories. I don't know which is right.
Whether the "10 agents per developer" number is the right shape or off by 10x in either direction. It might be 50 agents per developer by 2028. It might be 2 agents per developer because the meaningful unit becomes "agent team" rather than "individual agent." We are guessing in the dark on this one and anyone who tells you otherwise is selling something.
I list these because I want you to feel less anxious about not having the answer. We don't have the answer. We're figuring it out the same way you are, in public, in the work, week by week. (For a thoughtful running commentary on this exact uncertainty, Latent Space and benn.substack.com are the two places I read most consistently.)
The closing question
So, will AI replace developers in 2026? That's the wrong question. It's the question that gets you the most clicks but it's not the one that helps you decide what to do on Monday.
The right question is the one you should ask yourself in the mirror this week: will you become the kind of developer that AI can't replace?
Not because you're faster than the agents (you're not, and you won't be). Not because you know more syntax (you don't, and you won't). But because you bring the things agents still can't bring on their own. Judgment. Direction. Rigor. Care. The willingness to say "stop, this isn't right, let's do it again" when an agent confidently produces something wrong. The taste to know what good looks like. The systems intuition to see what's missing.
That kind of developer isn't being replaced. That kind of developer is being paid more than ever, and is in higher demand than ever, and is shaping the tools the rest of the industry will use for the next decade.
The answer to whether you're going to be that kind of developer isn't in some research report or trend deck. It's in your terminal this week. It's in the project you're going to start tonight. It's in the agent you haven't directed yet, on the codebase you haven't shipped yet, for the user you haven't talked to yet.
Go build something. Let us know how it goes. We'll be here, still figuring it out alongside you.
