Front-end is dead and those are good news for everyone. The bottleneck that kept ideas trapped in non-technical heads just broke. It is not simply easier to work around. The barrier of entry to produce UI that is functional is gone.
For the last 10 years, if I had a vision for a product, I needed to write code or find someone who could (expensive, slow, never quite right). That’s over. I’ve spent more than 1 billion tokens in the last two months watching agents write code I couldn’t write myself. I’ve shipped complete flows for a cybersecurity platform, built AI evaluation engines, and run multi-agent systems that critique design output.
Working with AI agents is chaos though. I’ve spent nights running 3-4 agents simultaneously, treating them like unpredictable interns. One works on a component while I’m prompting another about something else. They run off for 10 minutes. I move to the next thing.
When they mess up, I revert and try again with fresh context. I tend to fail forward because that is sometimes better for the quality of the output. I believe that for an AI is better to continue learning from the mistakes as it fixes them than ask it to back track and pollute the context.
More than 6 months ago, in a conversation with Mayank Gupta, Peter Steinberger—creator of Clawdbot (now OpenClaw)—called AI agents “slot machines for programmers”. Type something in, something amazing could come out. Or you break everything. Same prompt twice, different results.
This feels wrong if you learned traditional development. But the speed gains are real. Since I adopted this new workflow, AI is doing the heavy lifting and I’m building things in hours that used to take weeks. Not because AI is perfect, but because the iteration loop got so fast that imperfection doesn’t matter.
As a product designer, I’ve always been more interested in what gets built and why it should be built, than in how it gets built. But the how has changed forever. And I’ve changed with it.
For PMs and Strategic Product Designers
This new way for building is as game changer for PMs and designers. The PM who’s been sketching interfaces for years. The strategic designer who can see the product but keeps hearing “six-month build.”
The tools caught up. Component libraries matured. Shadcn, Radix, Material UI give you production-grade building blocks with accessibility baked in. When the Lego bricks are solid, assembling them becomes easy. Product leaders don’t need to keep watching their team drown in backlogs while competitors ship weekly.
AI learned to wire things correctly. Not perfectly, but correctly enough. Trying to innitate a project via a Boilerplate used to take a day, now it takes minutes.
So much so that web applications manage to abstracte the hard parts completely. Lovable handles authentication and databases. Replit and Vercel handle hosting. The infrastructure that required DevOps knowledge is now a checkbox.
The Prompting Approach
The prompting approach that works for me is to explain what I want from multiple angles. Like I’m talking to someone who doesn’t know my product. Sometimes my prompt is rambling. “The padding looks off. It needs to be like this design, with this style and that animation.” Voice input using WisprFlow works even better since I talk faster than I type.
AI agents are juniors that are sometimes brilliant and sometimes stupid, and they all have short-term memory. Mix unrelated stuff in one conversation and they get confused. Different tasks, different windows.
If the agent is confidently wrong about domain logic, I step in. If it’s iterating on implementation details (styling, refactoring, test coverage), I let it run. Trust the AI on how, verify on what and why.
What Works and What Doesn’t
What works: personal productivity tools, internal team tools, prototypes, landing pages, simple data apps.
What doesn’t work yet: complex multi-user systems, SOC2/NIS2 compliance, high-traffic production, enterprise integrations, anything where security is critical.
When I can prototype, my conversations with engineering change. I build a rough version first. The code would make engineers wince. But it works. I can click through it. The conversation shifts from “here’s what I want, go build it” to “here’s a working version, how do we make this real?”
This is where product leadership shows up. I’m not handing off requirements anymore. I’m showing direction and clarifying my intent. The prototype isn’t the product,it’s simply the conversation starter. I have noted that being trowable code is has come to replace the wireframes and prototypes of the past. It is a more complete way to validate the idea and get feedback from the team or actual users. I will write more about the dissapearing middle work of PMs and designers in a future post.
For Front-end Developers and UX/UI Designers
Everything I just said about PMs and strategic designers affects you. But the implication isn’t “learn to code faster before AI takes your job.”
UI implementation didn’t get marginally cheaper. It got structurally cheaper. The cost curve changed shape. The gap between “design intent” and “working first draft” collapsed from days to hours for standard patterns.
Where AI removes work: state wiring, boilerplate routing, form logic, test scaffolding, CSS alignment.
Where AI fails: accessibility edge cases, performance under load, complex state management. And critically, consistent interaction contracts across dozens of screens. AI can build a filter component. It can’t ensure your filter component behaves the same as the nine other filter components across your product.
That’s where the constraints were removed and the value of using AI for implementation and design moved up the stack.
Front-end Composability
Front-end composability is a different unit of work. Instead of building screens one at a time, I’m defining what UI states are allowed across hundreds of screens I’ll never directly touch. What can vary and what can’t. Buttons can be primary, secondary, or ghost. Not 47 custom variants. Tables have filtering and sorting, but interaction patterns stay consistent.
I’m defining the interaction vocabulary that both humans and agents use. When a PM prompts an AI to “add a filter to this table,” the agent needs guardrails. Without composability work, it invents a new pattern every time. With it, the result is consistent.
When a PM opens Lovable and describes a feedback form, they’re relying on component libraries that work, interaction patterns that make sense, accessibility standards that hold. Someone built those foundations. That someone is you.
The New Discipline
The new discipline: building infrastructure that lets non-engineers ship front-end safely. Ensuring that when five different people push UI changes, the result coheres instead of conflicts.
This is where UX/UI designers gain leverage. You already think in systems. Design tokens, component libraries, interaction patterns—that’s the vocabulary. The shift is from producing artifacts to producing the constraints that guide artifact production.
Value isn’t in how many screens I build. It’s in how many good screens I enable others to build.
My new pace is building analytics dashboards in 4 hours, release automation systems in 3 days, apps that 20-person teams maintained for years can be rebuilt in two afternoons. This happens when iteration loops compress and I stop being precious about reverting.
For PMs and strategic product designers the door is open. Keep waiting for engineering bandwidth, or spend two hours this week building something.
For front-end developers and UX/UI designers the job is forking.
- Path 1: Own the composability UI domain. Own primitives, workflows, guardrails. Less direct making, more leverage with AI-powered control over the Design System. Craft knowledge becomes context for setting constraints and embedding taste into the products. This is going to be the new default UI work.
- Path 2: The highly crafted user experience. Polished consumer products still need custom rendering, intricate interactions, performance tuning. AI-generated interfaces still need humans evaluating and improving every line. This is a specialist niche of AI-evals for now, not yet the default experience.
Both builders and implementers need each other. Product leaders without composability get chaos. Designers and developers without business context, clear intent and correct direction become isolated and irrelevant.
The Takeaway
Front-end is dead in the sense that hand-crafting pages is ending.
But long live front-end engineering with AI as the translator of intent into code. The craft shifted from implementing pages to designing systems that enable pages to be generated reliably. From making to enabling making.
The builders finally got their tools. Not perfect tools. Chaotic, non-deterministic, sometimes maddening tools. But enough to change who gets to create.
If you haven’t experimented with Claude Code or similar tools, start today. Not because your job is at risk. Because you’re missing out on the most interesting shift in how software gets made.
Pick a CLI agent. Decide what you want to build. Spin it up. Start working on what problem it solves by testing it and iterating with every person who would validate the value.
The real unlock isn’t the tool. It’s the mindset: you’re not learning to code—you’re learning to direct systems that code for you.
With AI, the implementation barrier for digital interfaces is gone. You just need to ask, and it will be done.