The 'Ferrari Uncle' and 45 Years on One Craft: Senior Engineers Are Being Repriced in the AI Era

Careers in the AI Era · 2026-05-04

Xu Wenbiao, 57, went viral recently. During a break at a Beijing sports meet, a few dozen judges in formal suits spontaneously broke into Latin dance. The middle-aged man leading from the center outclassed everyone on the floor, and the internet named him "Ferrari Uncle." A clip of a few dozen seconds was everywhere within days.

A lot of the commentary filed it under "midlife comeback." That's not what it is. Xu Wenbiao is a professor at the Beijing Dance Academy, a professional who has spent 45 years on Latin dance; actors like Sha Yi, Jin Dong and Liu Yifei have all studied with him.

What stunned people wasn't "a middle-aged guy can dance." It was that among a crowd of judges dressed identically, his bearing and the precision of his movement got recognized instantly. Behind that is a colder market signal: the public is starting to pay for depth, and professionalism is commanding a premium again.

This has a lot to do with your career in tech, with your anxiety about turning 35, and with whether you should pivot into AI.

Don't read Xu Wenbiao as inspiration porn

Short video manufactured an enormous volume of "master it in 7 days" content. Over the past three years: "become a developer in 3 months," "build a Xiaohongshu following in 30 days," "ship an AI app in a week." Attention-grabbing narratives whose actual output inflated away extremely fast.

Once the apparent entry bar for any skill gets dragged to the floor by crash-course content, what becomes genuinely scarce is the opposite pole: the stability, coherence and judgment that come from 45 years on one thing.

Xu Wenbiao isn't an isolated case. In the same window you can see:

On content platforms, "long-form deep analysis" and "hardcore industry research" getting weighted back up by the algorithms
In enterprise buying, companies cutting purchases of "AI crash-course consultants" and returning to industry veterans
In paid knowledge products, pure methodology no longer selling, while practitioner retrospectives — "I spent N years in industry X" — turn into hits
In investing, "LLM wrapper" projects struggling to raise while projects with real industry data or accumulated domain experience get fought over

Same underlying logic in all four: when production cost collapses, judgment becomes the entire price. And that rule is hitting the tech industry at accelerating speed.

AI killed shallow skills and amplified deep judgment

The most painful truth of the past two years: the code output of a 1-3 year engineer got compressed by AI into a few hours.

Write a CRUD endpoint, wire up an API, add a component — AI does these as well as a junior engineer, often better. So junior engineers' market leverage got flattened. That's a fact; you can read it straight off the hiring data.

But something else happened at the same time: senior engineers got scarcer. Not because AI can't write code, but because AI can't answer questions like these:

Will this change blow up dependencies in three downstream teams?
Will this architecture still hold in three years, or is it another debt entry?
Why did the last design review fail? Does this proposal dodge the same mine?
Is this P0 actually urgent, or is the tech team using "a performance problem" as self-redemption to avoid the genuinely hard business question?
Can this team structure survive the next 18 months of accelerating demand?

None of these are skill questions. They're engineering judgment. Judgment comes from handling one class of problem N times over, and AI can only sharpen it. It can't substitute for it.

Result: shallow skills depreciate, deep judgment appreciates. The gap is widening, not closing.

Why judgment lives with senior engineers

Judgment sounds mystical. It isn't — it has a specific source.

The reason people spotted Xu Wenbiao as "the one in the center" within seconds isn't that he learned a few more steps than everyone else. It's his fine-grained control over every part of his body — timing, muscle tension, facial expression, the subtle switch between pause and burst. That's muscle memory ground out over 45 years. You could watch ten thousand dance tutorials and not get it.

A senior engineer's judgment is the same substance:

You look at a PR and smell trouble within three minutes — because you got burned five times on similar PRs over the past decade
You look at a team plan and know immediately that the deadline is impossible — because you've shipped 30 projects of that size
You look at a hyped new technology and stay calm about whether it's a real trend or a hype cycle — because you lived through blockchain, the metaverse and Web3 start to finish

That kind of nose can't be described to an AI in a prompt. It lives inside the real complexity you've handled.

My own case: rolling out AI Coding across a team, systematically

My team is 20 people. Pushing AI Coding through it systematically, the real resistance was not what most people imagine.

The biggest obstacle wasn't "AI isn't good enough." It was that everyone already had their own way of doing it, and everyone thought theirs was fine.

Some are Cursor people, some Claude Code people, some Copilot people, and some hold on to IDE autocomplete
Every one of them can produce a case: "look, my method solved this"
But the team had no shared methodology. Who does a new hire learn from? If one person leaves, does their practice leave with them? How do you turn a personal trick into a team asset?

The second obstacle was a few senior colleagues who had concluded early that AI wasn't capable enough.

They'd tried early models, landed on "AI can only write demos, it falls apart on complex business logic," and that verdict hardened. New models shipped and they wouldn't retry. What I realized later: the problem was never model capability, it was usage — spec, context, workflow. Give the same model a vague requirement versus a complete spec and the resulting code differs by an order of magnitude.

What I built comes down to one sentence: an in-house harness built on multiple coding agents, turning personal tricks into team infrastructure. On that shell I landed three workflows:

1. Task tiering — two tracks, by size

Small (clear boundaries, typical CRUD / tooling scripts / bug fixes): full agent flow
Large (architecture changes, cross-module work, uncertain business logic): a human must drive the spec design, the agent assists on implementation

The distinction isn't difficulty, it's whether the spec is clear. Handing a vague spec straight to an agent is burying a mine for yourself.

2. A mandatory review checklist for AI output — three gates, and "unit tests pass" isn't one of them

Is the spec design sound: not "is the code correct," but "what did the agent understand the requirement to be"
Smoke test: you run the key paths by hand. The agent saying "all passing" does not count
Code diff: line-level review, looking for changes that look right but changed behavior — a default value edited, an error-handling branch quietly dropped

3. Bail out instead of patching — patching costs more than redoing

Even after all three gates, if PR review turns up that the agent touched something you didn't notice, or introduced a dependency nobody agreed to, revert and redo immediately. Do not patch. The cognitive cost of patching is far higher, because you first have to understand why the agent did it that way, then work out how to undo it without breaking anything else. That's more mental effort than letting the agent redo it once under a tighter spec.

This harness cut the variance in the team's AI Coding output dramatically. Senior people stopped writing off AI over one bad experience, and new hires stopped "watching someone else use Cursor with no idea where to start."

This is worth far more than "using AI to write code." It came out of years of stepping on engineering landmines: how to build a process, how to set review standards, how to handle internal disagreement about tooling. None of that is copyable from model release notes.

In the AI era, the engineering experience and organizational judgment that looked obsolete turn out to be the real differentiator — because anyone can use the model, but the person who turns a model into stable team throughput is the scarce good.

Concrete moves for three groups

0-3 years: don't believe "AI lets you leapfrog"

AI lets everyone write code. It doesn't let everyone make engineering decisions. If you want to close the gap with senior engineers:

Don't spend time collecting 100 prompt templates — anyone can copy those, there's no edge in it
Spend time getting beaten up on real projects — join cross-team work, volunteer for the hard tasks, do an honest retro after you get yelled at
When picking a company, favor teams with complex business, deep tech debt and real organizational friction — that "hard" is the soil judgment grows in

The most dangerous state for a junior is "using AI to finish easy tasks efficiently," because it makes you feel like you're growing when you're just consuming easy tasks faster.

3-7 years: AI is leverage, not a replacement

You're in the window where using AI matters most. But not the way a junior uses it:

Treat AI as your coding intern — hand it the things you don't want to spend time on but must do: docs, test edits, boilerplate, digging through legacy APIs
Free your attention for the genuinely hard things — architecture choices, cross-team coordination, hairy debugging, understanding the business
Ask yourself once a week: could AI do what I did this week? If yes, what harder thing do I take on next week?

The mid-career trap is "AI made my job easier." Nothing wrong with that — but if six months from now you're still doing what you were doing six months ago, you're paving the road to your own layoff two years out, because the company will eventually notice you can be replaced by AI plus one junior.

7+ years: your judgment has a market premium for the first time

Your seniority used to be an implicit company asset with no way to monetize. That changed:

AI turned engineering judgment from an internal capability into an external good — the frameworks in your head can be priced directly as writing, internal training, consulting
Structure your judgment as output — take the specific landmines you've stepped on over the years and write them into methodology other people can reuse. Ten pieces is enough for your IP to have value
Stop being anxious about "getting cut at 35 or 40" — that's the 2022 narrative. The 2026 narrative is "we can't hire seniors who can make technical decisions in the AI era"

Where to start, concretely:

List the five most painful engineering decisions of your past five years — architecture, people, tech debt, a failed project
Write a 1,500-word retrospective on each, and in the conclusion, write like a consultant: 3-5 judgment rules someone else can actually execute
That's your senior IP asset. Five pieces to start, ten to build momentum

Closing

Forty-five years on one craft sounds romantic. It isn't romance, it's market. When everything else is inflating faster, slow and careful becomes the scarce asset.

Xu Wenbiao going viral isn't an individual inspiration story. It's an early signal of the market repricing professionalism. The same story is playing out in tech: shallow skills keep depreciating, deep judgment keeps appreciating.

To the veterans out there — the AI era is exactly your moment to step forward. Stop worrying about your age, and go take those judgment frameworks you consider obvious, and structure them, externalize them, productize them.

The market is already ready to pay for depth. You just haven't noticed the window.