> I enjoy interfaces and workflows and visualizations. I don't want you to feel like I'm attacking frontend or frontend developers.

I hope you mean that but it's hard to see it that way based on your original comment and responses. The trope of "frontend is not a serious job" has been infuriatingly going on for a long time before LLMs took the center stage and that seeps out of the things you've said so far.

But, I'm glad if you mean what you said above.

> Here's where I'm coming from: A shockingly large amount of interesting frontend work can now be done, reasonably well, by an LLM. Sure, it's no staff frontend engineer, but you now have people who can't code at all who can dream up little apps and have the LLM actually just build it for them, something actually useful. That is absolutely incredible to me.

And this is where I'm coming from, based on your original reductive narrative on LLMs overtaking frontend and that the field is somehow at risk — if you feel the same way, you can apply these _exact_ arguments to a _shockingly_ large portion of backend too. I could say most are just glorified spreadsheets. Moreover, a lot of startups just use one of the "serverless" platforms and won't think twice about database, devops, security, authn/authz until they hit an escape velocity.

But I personally think meaningful engineering solving real-world problems at scale that is meant to be an enjoyable experience for the user should be well thought through, end-to-end, regardless of the smaller scopes within.

> Candidly, I just don't see the same momentum for AI in the database/infra space, and speaking personally, I thought it was the right move to shift in that direction.

Partly, I think you are probably forgetting that a lot of these startups promising all of this also promise the backend stuff, even if you might disagree with the choice of tech stack (usually React/Next w/ Supabase/Planetscale/Firebase) and the deployment environment (usually something like Vercel). And the reason why the frontend part is front and center is because... well... that's what the users ultimately interact with. They don't give two shits about the stack (front & back) as long as the product works and works well. But it'd be naive to think this didn't involve all the automated code being spit out on the backend side as well.

And let's forget AI for a moment, by this line of thinking, a large portion of the backend engineering you talk about have been available in simplified forms via serverless offerings or via low-code offerings. Same for databases, including branching and claims of seamless migrations and backup. So, maybe you should have started panicking way before modern LLMs hit the scene? :)

But you probably won't because like me, you realize it's not that simple and it's not always practical. Same reason why I am not using Framer/v0/<insert fancy new tool here> to build a non-trivial front-end app with growing complexity.

I'm a cautious optimist in this space. I do think the tech we got so far is cool and groundbreaking and I use them extensively for noodling. But at the end of the day right now, they're still tools. We are seeing the AI leaders shifting goalposts every day, complain about lack of data etc. and I honestly believe we are many more breakthroughs away from getting to the dream world you're thinking of, especially when broadly generalizing things.

> Aside: I'm also pretty sure you can find plenty of "AI" companies promising automated DevOps/Backend/Database etc. just within https://www.ycombinator.com/companies (try keyword searches).

> The trope of "frontend is not a serious job" has been infuriatingly going on for a long time before LLMs took the center stage and that seeps out of the things you've said so far.

Eh, sorry I came across that way. To me, seeing a complex system visualized, making it interactive, is just so beautiful. That's a big part of why I got into frontend in the first place. I wouldn't take anyone seriously who doesn't think frontend is a serious job.

I also suspect that you are doing more complex, and finely judged frontend work than I did - I took a peek at your public profile ;). So it's not surprising that we have different impressions. If someone is building a frontend that needs to work seamlessly for billions of people across many devices, that sounds incredibly challenging and frankly I've never even tried to do that so I can't even comment on it.

But, I would say that a lot of the frontend work that I find interesting can now be automated with LLMs. Historically, I've tended to build internal tools that usually had a fixed runtime environment and small number of users. So I'm not as worried about the fine points of the web, but about creating a lot of features and interactivity in a particular, easily tested environment. I would wager that the average frontend developer is doing work somewhere in between the two of us.

> you can apply these _exact_ arguments to a _shockingly_ large portion of backend too

Hmm, I think we just disagree here. I think a lot of my view comes down to how frontend ultimately needs to collapse into something that can be visualized and interacted with, and this helps force the state to evolve in sane ways. On the other hand, I think backends quickly grow from a spreadsheet to insane, highly-dimensional, highly-coupled nightmares that no one can really visualize anymore, first at the logic level and later at the architecture and schema levels.

Ultimately LLMs are helpful when they can sort of grok the overall structure and plan of your code and add stuff helpfully to it. I think that LLMs have more public examples of frontend codebases and that helps them follow the overall structure a bit better. In my experience, LLMs are doing a bit better in trying to add small features to large frontend codebases than to large backend codebases, probably for this reason.

Finally, you can often define what changes are wanted on the frontend fairly precisely. A series of mockups plus descriptions of the interactions carries a lot of detail. On the other hand, backend changes often interact implicitly with unstated business context that you can't get solely from the backend code itself (this become particularly tough when you try text-2-SQL, for example.) So I think many backend and architectural changes have inherently vague specifications that need to lean heavily on context that's not captured in the ticket.

None of this is meant to undermine the seriousness or difficulty of frontend as a profession. But it is still my opinion that, on average, LLMs have a better chance of doing useful things on the frontend than the backend.

I thought about this a bit more, and I think the boundary between front end and backend can be a bit artificial. Theoretically, one could do highly complex state management and data flows on the front end, even run your own database, etc. Not to mention complex dependency trees. All of this can and does happen, but in my mind this starts to leak into what I’d consider backend work anyway, just coincidentally happening in the browser. And I don’t think LLMs are particularly good at automating any of that.

But I think there is a huge chunk of work, which most people think of as front end, which is displaying pre computed data according to a particular pattern, and providing hooks into the backend for additional interactivity. I think that this piece can be largely done by LLMs now.