AI Didn't Kill Frontend — It Killed Pixel-Pushing
The career of a frontend engineer reaches an extremely cruel watershed in the fifth year.
In the first five years of entering the industry, your salary increase relies almost entirely on proficiency. You memorize the principles of React by heart, you can configure an ultimate Webpack or Vite project with your eyes closed, and you slice layouts with Tailwind CSS twice as fast as others. You feel very strong.
Until 2026, the arrival of large AI models.
Overnight, you suddenly discover: while you were still urging the UI designer for design slices in the group chat, your boss has already used Codex or a domestic large model to generate a complete and extremely beautiful Vue backend management system code from a sketch in 10 minutes.
Panic begins to spread. Major companies start frantically cutting frontend headcount, and many people despairingly believe that frontend is dead.
But this is actually a huge logical fallacy. AI has not killed frontend; it has only killed the ancient methods of frontend programming.
Face Reality First: Are You Still Doing Ancient Programming?
What exactly is ancient frontend programming?
You can look down at your daily workflow habits: opening a Figma design file, manually writing display: flex and margins pixel by pixel; staring at the backend's Swagger API documentation, manually translating TypeScript interface definitions line by line; finally writing a boring map loop to stuff data into identical table components.
This is the bloodiest eruption point of this year's frontend AI layoff crisis.
Many people's perception of large models is still pathetically stuck at it's just a code completion tool that is occasionally useful. They have no idea that on the real business frontline, Codex or enterprise-level Claude Code has long transcended the dimension of single-line code. Your boss or a non-technical product manager only needs to throw in a design file link, and within tens of seconds, a business component containing perfect Tailwind CSS styles, complete React Hooks state management, and even pre-written Mock data is generated.
If your salary confidence comes solely from your previous extremely mechanical proficiency in ancient frontend programming, then being replaced by a large model is not a question of whether it will happen, but when management decides to tighten the budget and control costs 🤔.
Own the Right to Define Data First
We used to complain often: The APIs provided by the backend are too disgusting; I have to make 5 serial calls just to assemble one page, and the rendering is painfully slow.
How do you solve this now with a full-stack approach? You simply don't write that extremely disgusting Promise.all data cleaning code. Instead, you cross the boundary directly and deliver a dimensionality-reducing strike 🫵.
When you find that the backend's API does not conform to the best intuition for UI rendering, you must have the confidence and ability to slam the table. You need to introduce a BFF (Backend For Frontend) layer, or directly use Cloudflare Workers to write a middleware at the edge node. You forcibly intercept dirty data at the middle layer, performing trimming, aggregation, and caching.
Don't be the person who just receives interfaces; become the person who defines the protocol.
When the data reaching the browser is always an extremely clean, highly customized, perfect payload that requires not even a single data transformation, it's hard for your frontend page to lag. By controlling the right to define the data flow, you control the discourse power of the entire business 🫡.
The Deep Water Zone AI Cannot Touch
Large models write code very fast, but they have a fatal problem: the code they write only lives in an ideal environment without network jitter, memory leaks, or concurrency limits.
Let's look at an extremely common business scenario: polling a real-time updated chart data on the frontend. If you let AI write it, or hand it to an average frontend developer, they will almost 100% spit out this pseudo-code:
// Completely disregarding the user's page experience
useEffect(() => {
const timer = setInterval(() => {
// Blindly initiates requests, completely ignoring whether the previous request is stuck
fetch('/api/dashboard/data')
.then(res => res.json())
.then(setData);
}, 1000);
return () => clearInterval(timer);
}, []);
This code runs perfectly fine locally. But in a real production environment, if the user switches to another webpage to watch a video, this code will still madly send requests in the background, wasting server bandwidth and user bandwidth for nothing; if encountering a weak network environment on a high-speed train, the next request is sent before the previous one returns, eventually causing the browser connection pool to instantly overflow and the page to freeze completely.
A senior frontend developer, however, holds the trump card of engineering fallback capability that ensures the system never crashes even in extremely harsh network environments:
// Precisely squeezes browser performance, never wasting a single server resource
export function useResilientPolling(apiUrl: string, interval = 1000) {
const [data, setData] = useState(null);
useEffect(() => {
let controller = new AbortController();
let isPolling = true;
const poll = async () => {
// If the user switches to another tab, immediately freeze polling
// Never waste expensive server bandwidth and database concurrency with invalid requests
if (document.visibilityState === 'hidden') {
setTimeout(poll, interval);
return;
}
try {
const response = await fetch(apiUrl, {
signal: controller.signal,
headers: { 'Cache-Control': 'no-cache' } // Penetrates all hidden caches
});
if (response.status === 429) {
// When encountering backend rate limiting, actively circuit-break and trigger delayed backoff
// Actively protects the backend system from being completely overwhelmed
console.warn('Backend pressure overload, triggering circuit-breaker backoff mechanism');
await new Promise(res => setTimeout(res, 5000));
} else {
const result = await response.json();
setData(result);
}
} catch (err: unknown) {
// Silently swallows actively aborted errors, never polluting the global error monitoring system
if (err instanceof Error && err.name === 'AbortError') return;
} finally {
if (isPolling) setTimeout(poll, interval);
}
};
poll();
// In the extremely tiny moment when the component is unmounted
// Completely seals off the source of memory leaks for abandoned network requests that haven't landed yet
return () => {
isPolling = false;
controller.abort();
};
}, [apiUrl, interval]);
return data;
}
Do you understand? In this code, not a single line is writing UI; every line is fighting against the harsh real production environment.
This is the essential difference between you and AI. AI provides code implementation, while you provide a professional protection layer.
Not Writing Code is the Highest Form of Architecture
After 5 years of work, true masters slowly develop an extremely cold business sense: not writing code is the highest form of architecture.
When a product manager brings an extremely complex interaction requirement, the average frontend developer's first reaction is: How do I write this animation with Framer Motion? Should I introduce Zustand for this state?
But for old hands like us, it's: How much order conversion will this feature bring? Is it worth investing 3 developers' cycles to maintain?
If the answer is no, we will not hesitate to directly find a third-party SaaS service, or use the crudest iframe to embed someone else's existing page, or even use AI to cobble together a usable version.
In the eyes of the CTO and the boss, your ability to help the company test a new business in an extremely ugly but zero-cost way is ten thousand times more valuable than spending a month writing a set of flawless TypeScript generic components 🤔.
Don't Complain About the Big Picture
The rapid advance of AI has indeed torn apart the comfort zone of frontend newcomers, completely ending the bonus era where casually knowing a framework could earn you over ten thousand a month.
But this is by no means a bad thing. When those repetitive tasks with no technical content are taken over by large models, frontend engineers can finally free up their hands to truly dive into the deep water zones of network protocol stacks, memory governance, server-side rendering, and edge computing.
So what determines the ceiling of your salary is never those problems that can be easily solved by search engines and AI, but the sensitivity to extreme environments, control over team efficiency, and stable delivery of business that you have accumulated after 5 years of struggling in this industry.
That's all for today. If you like it, please like and save it, and send it to those around you who need it 🙌