11 ms·

Is AI causing a repeat of frontend’s lost decade?

• iLoveOncall 5mo ago
  > JavaScript frameworks have deskilled frontend development in the last decade. As someone who started with HTML/CSS and a bit of PHP, later did Ruby on Rails, and then was frontend team lead of a major Swiss newspaper (Next.js at the time), I’ve seen the transformation first-hand I'm sorry but that simply does not make any sense. How is increasing the breadth of your skills leading to a deskilling?
  • WesolyKubeczek 5mo ago
    The phenomenon of bootcamp graduates who knew React but did not know JavaScript.
    • cryo32 5mo ago
      yes and now they get Claude to write React and don't know that or JavaScript. When something goes wrong, no one understands anything.
  • lpcvoid 5mo ago
    [dead]
  • seszett 5mo ago
    The article explains at length what they mean by "deskilling" and it does not mean that individuals lose their skills. The author having worked with various technologies over time is also not an example of "deskilling", it's a way of asserting that they have had time to observe the deskilling of the domain (since deskilling means a particular domain requires less specialised skills than it did before, not that the workers are losing skills) happen.
  • gobdovan 5mo ago
    Read in context. He's referring to the evolution of skill at group level, he even puts out the definition of deskilling and mentions 'skilled labor'. He then explains how frontend used to be a 'highly specialized skill', and how modern devs use Frameworks to consider browsers almost hidden compilation targets.
  • efsher_azoy2 5mo ago
    I guess the author never tried to write big FE application in jQuery :D It definitely required some skill.
    • llbbdd 5mo ago
      They're in good company with most of these replies, apparently. Lots of sour grapes in here.
  • epolanski 5mo ago
    Just watch the terrible soup produced by MIT-bred Leetcode ninja "engineers" in money raining startups and FAANGs. Low accessibility, terrible performance, lack of any fundamentals of html and css, abuse of those awful solutions like Tailwind or using 2016 technologies like React for rendering what should mostly be static websites + some web component, all plagued by memory leaks and very basic usability bugs.
• WesolyKubeczek 5mo ago
  > frontend used to be a highly specialized skill, requiring knowledge of semantic HTML, CSS, the differences of various browsers, accessibility, progressive enhancement, network performance, interface design and user testing I remember this period differently. The frontend work was mostly, sometimes solely, all about turning whatever monstrous PSD came from the designer’s sick mind into HTML, and getting shafted if the result was not pixel-for-pixel identical. When project leads heard the word “semantic”, they had to reach for the dictionary. Upon hearing the word “accessibility”, they would set the dictionary on fire.
  • altmanaltman 5mo ago
    nostalgia is one hell of a drug
    • WesolyKubeczek 5mo ago
      Web has always fucking sucked, and it fucking sucks today. The only way to make the web technologies not suck is to use them to power a vacuum cleaner.
      • danielbln 5mo ago
        Please no, I need my vacuum to work reliably in every room.
  • actionfromafar 5mo ago
    I think there might have been two overlapping periods, but it definitely started out as you said. What I wonder is, will AI increase frontend churn, or calm it down? (More churn would be, new frontends because of new frontend frameworks, AI accelerated, less churn would be, because AI is trained on what existed before) I think I also reject the premise of the article, that frameworks caused frontends dev to de-skill. For sure, that happened to some extent. But it also caused a lot of frontend devs to be incredibly skilled in their chosen niche. (React for instance.)
    • 5mo ago
• 23david 5mo ago
  I think it's more likely to cause a lost Decade of people not going into CS or tech due to lack of entry-level jobs. Maybe next time there's a boom and the pendulum of the power dynamic between management and labor swings more towards the workers, tech workers will unionize or organize better. I think overall it will benefit the industry because these boom and bust cycles for employment are just not healthy.
  • reaperducer 5mo ago
    I think it's more likely to cause a lost Decade of people not going into CS or tech due to lack of entry-level jobs. That could be a good thing, or a bad thing. Maybe it will push more people into medicine, science, art, or other worthwhile careers. Or maybe they'll end up lawyers, SEO experts, or venture capitalists. It could go either way.
  • jazz9k 5mo ago
    Unionized workers are also losing their jobs in this economy. Unions are, by nature, anti-progressive. They would rather use 15 year old technology, then replace workers and allow efficiency. This will never work in the tech industry.
  • Traubenfuchs 5mo ago
    There is no guarantee that there will be a boom again. Some jobs disappear. Maybe we'll really only need a handful of elite engineers who continue advancing the foundational tools we use (kernels, databases, hyperscale low level cloud products, drivers, etc.) and the rest of "programmers" and "software engineers" will be replaced by "prompt engineers". With a new generation mostly unable to read and reason about source code.
    • alex_suzuki 5mo ago
      But how will the current crop of “elite engineers” be replaced, when they inevitably age out?
      • Traubenfuchs 5mo ago
• kristianc 5mo ago
  I'm sure I'm not alone in feeling the "deep expertise" OP laments was actually deeply inconvenient to many people. I understand that there's a good living to be made from knowing browser quirks, hand-rolling accessible components, mastering CSS specificity, but this is largely accidental complexity. More people building things is straightforwardly good, and if some of those things are slower or less accessible, that's a tradeoff people are entitled to make. You can argue that abstractions hide consequences that fall on users who didn't choose them, but I'd argue back that LLMs likely have a better understanding of a11y conventions than I do as well.
  • sdevonoes 5mo ago
    Most of software engineering is accidental complexity. Sharding, buffering, caching, load balancing, contention, async, functions, classes, recursion… Big corporations behind LLMs are taking it all.
    • dannyw 5mo ago
      There's a huge difference between everything you mentioned, and dealing with 'browser quirks' like: <!DOCTYPE html> <!--[if IE 8]> <html lang="en" class="ie8 no-js"> <![endif]--> <!--[if IE 9]> <html lang="en" class="ie9 no-js"> <![endif]--> <!--[if !IE]><!--> <html lang="en" class="no-js"> <!--<![endif]--> The points the author made simply aren't good arguments. Yes, frontend development was harder during those days, but not harder in a good or rewarding way.
    • layer8 5mo ago
      That’s not what accidental complexity means. Accidental complexity comes from design errors that could have in hindsight been avoided, meaning that if those errors hadn’t been made (made by accident, literally), there wouldn’t be any accidental complexity. The items you list aren’t accidents that could be avoided, they are necessities in achieving relevant goals.
    • sevenzero 5mo ago
      Sharding, buffering, caching, load balancing are mostly issues 99% of devs will never have to work on. It gets relevant on high load pages, but most stuff out there wont ever need it.
• Npovview 5mo ago
  if you value intelligence (and likely income from that intelligence) above all other human qualities, you're gonna have a bad time. -Ilya.
• Zababa 5mo ago
  The part on the Bauhaus movement is weird, and I'm not sure I agree about how the author thinks about users. >What did previous generations of craftspeople do when everyday goods and buildings suddenly could be mass-produced by industrial processes? One reaction was to copy the style of old, and make the industry crank out widgets and buildings that at least looked like they were handcrafted. Is this a reaction by craftspeople? I don't think it is, I think this was what industry people did? >Countering this trend of historicism, an alternative approach was developed by the Bauhaus movement of the early 20th century. Instead of pitting factory workers against craftspeople, their stated goal was to have them work together, and redevelop the arts and crafts with industrial manufacturing processes in mind. From what I understand the Bauhaus movement has/had a huge influence on modern architecture, which people tend to like less than traditional architecture [1]. It feels weird to have that followed by "Caring about quality and the user". >The industrialization enabled lots of cheap plastic products, designed by people who didn’t take the time to think how they would be used and by whom – yet good industrial design is still a thing. >And software like Wix and Next.js enabled the creation of lots of websites that load terribly slow and are not accessible – yet there are still practitioners of the front of the frontend out there. I think the author really really really underestimates how important is it that something is "cheap". I personally like a lot having the option to use cheap and relatively good stuff, or pricier and better stuff, for most things. This is a bit stretching the definition of "accessibility" but, I think in a way price should be thought as part of accessibility. If we consider that it's important that websites work well on slow networks, partially because not everywhere in the world has access to good network, partially because good networks cost money ; then I think we should consider that while a good website beats a bad website, sometimes a bad website beats no website. Sometimes a "cheap plastic product" means someone that can't buy the well designed product can still buy a product, and get started in a hobby. This is pretty bad news for craftsmen I think, but as a software engineer that is very happy to be able to get into crochet or photo or cyanotypes or pottery or hiking for relatively cheap, I can't help but try to see the other side of software getting cheaper. [1]: https://www.sciencedirect.com/science/article/pii/S0264275119311655 https://www.sciencedirect.com/science/article/pii/S026427511...
  • contingencies 5mo ago
• ElProlactin 5mo ago
  > And we’re saddened that the new process results in lower quality work, and that a lot of people just don’t seem to care. 1. Arguments like this seem to be based on the idea that, prior to AI, most of this type of work was being done by skilled artisans dedicated to quality work product. As I think anyone who actually worked in the industry and is being honest knows, this wasn't the case. There was a lot of mediocrity and worse. 2. I'm not sure the work is "lower quality" depending on how you define "quality". AI might result in an uncomfortable uniformity but at the same time, a lot of AI work product is pretty darn usable because the models have been trained against conventions that, love them or hate them, "work" for the vast majority of end users.
  • everdrive 5mo ago
    >1. Arguments like this seem to be based on the idea that, prior to AI, most of this type of work was being done by skilled artisans dedicated to quality work product. As I think anyone who actually worked in the industry and is being honest knows, this wasn't the case. I think this is more of "another brick in the wall." There was already a LOT of pressure to do the bare minimum to fulfill requirements and then declare success. Now, those pressures seem insurmountable.
    • ElProlactin 5mo ago
      If your requirements are reasonable and serve the needs of end users and the business, doing "the bare minimum" isn't such a bad thing. "I just remove everything that is not David." Of course, the requirements aren't always right, but in my experience, engineers/developers are just as capable as business owners of defining requirements poorly.
      • RugnirViking 5mo ago
        > If your requirements are reasonable and serve the needs of end users and the business Have you ever heard of the idea of malicious compliance? doing exactly what is required, and no more, is the path to ruin for all of us. Requirements will never work this way.
• neuroblaster 5mo ago
  Very interesting, i didn't know that frontend developers experienced deskilling before. I thought that slop was the usual way of doing things in frontend (or backend). Apparently deskilled people are making it look like this is normal and it supposed to be so. But i can relate to that. Another examples of deskilling would be, of course, Java, and a more modern example - Rust. That said, i don't think deskilling is solving mass-production problem. It was already solved with open-source software, or with a software as is. Software is information and there is little to no cost of copying information. So mass-production isn't the problem that is being solved here. IMO the problem being solved is that business need unskilled labor, that is slop. You would think that if business is producing slop, it will be replaced with another business producing quality stuff. If that was so, over time, there won't be any slop on the market, but if you open your app store, you are welcomed by all kinds of slop. Because slop is what they buy. Supply is only following the demand, business need to produce slop because people are buying it. How many of you guys have Claude subscription? Do you know that 5 years ago i would be asking "How many of you guy have GitHub Copilot subscription"? This is what people buy, so it is deskilling, but not a mass-production, it's just slop revolution, slop is the new norm.
  • fantasizr 5mo ago
    Everyone had a chance to learn vanilla js from the mozilla docs but using jquery was much much simpler. Concede that jquery is more difficult than prompting. The issue for me is that prompting a front end and everything looks exactly the same. More cookie cutter than what wordpress and wix offered
    • neuroblaster 5mo ago
      Right. So we are stuck with the jquery and wordpress forever. Because this is THE cookie cutter and it's good enough. But situation was exactly the same before the AI. You would still get your wordpress, your React frontend and Java Spring backend. AI doesn't change anything, it just takes the job of a poor slopper who made a living by coding React frontends. Anthropic just took their job, that's it, and you don't see the difference.
• wongarsu 5mo ago
  We already had a phase of "deskilled" frontend development: Adobe Flash. Any designer could open it and create interactive websites in it, no CSS or HTML knowledge required. Some slight JS knowledge (rebranded as ActionScript) you could get full interactivity, and animations were fully editable in UI. Sure, all of this came at a terrible price: no accessibility, no SEO discovery, huge loading times. But it also created some of the most innovative and artistic front ends. And a lot of things that should have never seen the light of day SVG+CSS+HTML were hailed as the modern replacement for Flash, but nobody ever made an authoring tool suitable for the masses. LLMs are kind of fixing that, just with a very different interface
  • neuroblaster 5mo ago
    Right. And Flash wouldn't end until Jobs won't come out on stage and say that Flash is eating the battery and Apple won't support Flash in their next iPhone, then Flash just ceased to exist. Apparently nobody needed innovative frontends anymore ¯\_(ツ)_/¯ There is no break pedal on this stuff, it just rolls down the hill until eventually it doesn't. It's a runaway process that feeds itself.
    • emodendroket 5mo ago
      He was able to do that because there were equivalent capabilities out there though.
  • Gualdrapo 5mo ago
    > Any designer could open it and create interactive websites in it, no CSS or HTML knowledge required. Please note that that "any designer" should have had at least a fairly decent knowledge of ActionScript because Flash wasn't all just magic and sparkles. I know this because I was one of them. Though I had to learn ActionScript by neccessity, I actually learned HTML/CSS/JS before needing to deal with AS
  • machiaweliczny 5mo ago
    Good news is that HTML in canvas might bring back these cool days :)
• yanis_t 5mo ago
  Are we getting some real data in any industry really where AI eating jobs? I was kinda expecting those to kick in by now, but don't think it's happening.
• sublinear 5mo ago
  > frontend used to be a highly specialized skill, requiring knowledge of semantic HTML, CSS, the differences of various browsers, accessibility, progressive enhancement, network performance, interface design and user testing – to just name a few. It still is! > To distinguish what they’re doing from what “frontend” has become, practitioners of this arcane art nowadays often refer to it as the “front of the frontend”. I have never heard this term before, but I'm sure someone will point me to the bullshit influencer who came up with it? Frontend frameworks are really just for web apps and most frontend devs are familiar with several. If they cannot also write a web page from scratch, they're not really a web dev. This is not up for debate. If you hire someone for the role, you need them to handle the work. AI is not going to help you here when it gets into the testing and bugfix phase.
• efsher_azoy2 5mo ago
  My humble opinion: “deskilling” is an illusion. Sure, I don’t write code by hand anymore, but I spend most of my time using the knowledge and “sixth sense” I’ve developed throughout my career to control what AI is doing. At the end of the day, I have to make more architectural and business decisions than before - it’s just higher-level and more complex work. On the other hand, there’s increasingly little reason to hire someone just to write APIs or work on the frontend, since AI handles most of the routine tasks. So, this feels much more like the Industrial Revolution than “deskilling.”
• kangalioo 5mo ago
  The "frontend skills" whose growing irrelevance are bemoaned in this article consist largely of navigating a minefield of unintuitive edge cases, browser incompatibilities, historic baggage, exceptions to exceptions to exceptions. Modern frontend, or the "tower of leaky abstractions", is finally a common-sense mental model for web development. Supplanted by force on top of an exploding bag of eccentricities that is web standards and conventions. The fact that it works at all and is merely a little leaky is an accomplishment in itself.
  • emodendroket 5mo ago
    That's true and it also seems like the bundle of C, Unix conventions, and so on, is similar in a way, but older and so we're more used to it.
  • berkes 5mo ago
    > a common-sense mental model for web development. You are contradicting yourself. Either its a "minefield...of edge cases..." Or it's a common-sense model. Not both. I'm convinced we're still in this minefield of edge cases, not in a situation where we've solved all this, and where the tech to build "frontend" is clean, predictable, free of historical baggage etc etc etc. All we have done, is plaster over these foundational mistakes and invcompatibilities. We haven't solved them. React doesn't solve the fact HTML was never designed to be a UI toolkit. Next.js doesn't solve the fact that JavaScript is full of design mistakes that prohibit it from ever becoming a safe, sane, reasonable (literally) language. Tailwind doesn't solve the problem of CSS being haphazardly introduced to style a markup which was never designed to be styled. Etc. All LLMs now do, is having the "knowledge" of the horrors under the plaster, in a statistical model that was trained on examples from an era where 99% of the examples are hardly more than plastering to fix the ever reappearing cracks in the previous layers of plaster.
    • deleted 5mo ago
      [deleted]
    • jeremyjh 5mo ago
      No, they are saying that the frameworks and tools discussed in TFA have made it look coherent. For the most part we have not worried about compatibility for a decade. All abstractions leak a bit but in practice it holds up quite well, well worth the cost savings and flexibility for many apps.
• culebron21 5mo ago
  I worked mostly on frontend in 2012-16, in plain HTML+CSS, and then quit, because React was required everywhere, and I tried and hated it. But before React, I don't recall frontend as very inspiring and joyful. It was fun to see your work immediately on the screen. I did apply skills and had to solve some weird situations. I could optimize our CSS with OOCSS approach (later used in Bootstrap) -- only to complaints -- semantics! too many classes! (my trump card was that their commits contained +200 lines of CSS, while mine mostly had 0 -- and our CSS was already bloated into several megabytes). But this was a dead end. I tried making tools to find out unused styles, to automate some patterns -- like click a button and load some content over Ajax. But the guys, who copy-pasted code with dumb solution to this, got 2-3x more tickets closed. I proposed a tool to make screenshots of pages and diff them to search for regressions, but the response was it's heavy RnD, we're not a research institute, we got to ship the next popup tomorrow, etc. Nobody gave a shit much earlier.
• mariopt 5mo ago
  I’m using AI to create UIs and I find myself having more time to think about UX rather than CSS. It actually gave me “time” to quickly test design ideas an implement minor details. I’m actually building better UIs just because it became less time consuming to do so. There is just a super noisy minority that spams the internet with slop so bad that no one can take their product seriously.
  • geophph 5mo ago
    Yeah coming from the backend world using AI for UI tweaks can really unlock me to have a decent looking app with reasonable UX in a much shorter amount of time. Maybe the code is “slop” but usually I can spend just enough time to take away the cognitive debt and still feel like I’m ending up in a better place
• cmiles8 5mo ago
  While AI coding helps a ton in building product prototypes, it also results in products that folks spot as AI from a mile away. Literally just saw startup demo their app and their app which had that “vibe coded UI” look to it. They were given devastating feedback of “Guys this is kinda cool, but you obviously had AI build this and thus anyone else that wants this can have AI build it for them too very quickly. As such there’s really no value in what you’re trying to sell here.” It was cold, but accurate feedback they needed to hear.
  • saratogacx 5mo ago
    What is funny about that is if you setup a basic design system, css and such, The AI generated front end code will fit right in nicely but most don't even go through that basic amount of care. Rounded corners still seems to be the unending trend through that anything that wasn't already well defined gets infected with.
  • pickleRick243 5mo ago
    This sounds like a fantasy in your head rather than something that actually happened. No competent VC would give meaningless feedback like this- if it's good, it's good; who cares if AI built it? If it's the same quality product but wasn't obviously vibe coded, then it would be fine? Only someone ideologically opposed to AI would care.
  • ai_fry_ur_brain 5mo ago
    Great, more of this. I cant stand llm generated UI nor the people that think its sufficient.
• jillesvangurp 5mo ago
  We're in the software industry. The whole point of that industry is automating things that are very repetitive. Frontend projects are very repetitive. And now AI is doing that for us. Fantastic, fees up a lot of time to build more interesting things. De-skilling for skills that just aren't that relevant anymore because we've solved the problem (with AI or otherwise) has been a constant in our industry ever since computers were invented. Move on, learn new skills. And actually effective use of AI is a skill some people seem to be struggling with. Stuff still doesn't build itself. If you can prompt it right, you can get it done. But are you prompting right? Are the tools doing what you ask them to do? How do you know? Did you check? I seem to spend an awful lot of time prompting AIs. I'm definitely getting better at it. But it's still a full time job. And I'm sure in a decade or so we'll look back on this as a very inefficient way to build software. The tools will get better. The AIs more autonomous, etc. Because if you spend a day doing repetitive things prompting the same things over and over again, somebody or something should probably automate that!
  • taken2000 5mo ago
    Instead of giving up on frontend the new efficiency to AI should free resources push the frontend further, the same for backend. The world needs lots of more software than we currently can create.
  • J_Shelby_J 5mo ago
    The point of software is to encode human will into machine communicable state. The entire complaint here is that automating this risks that was is encoded is not what you want.
    • andrekandre 5mo ago
      > The entire complaint here is that automating this risks that was is encoded is not what you want. this is the biggest issue to me; even if its code-generation was one-shot "perfect" (and beautiful) every time, people are gonna be less and less sweating the details and start throwing more mud at the wall to see what sticks instead of trying to understand their customer n=1 but i see this first hand all the time now, people dont even read the generated requirements/specs cause they are too long but it looks kinda ok so "lets have at it" smh
• williebeek 5mo ago
  My previous employer fired all front-end developers a few years ago, we went back from tons of frameworks (Vue/jQuery/Ruby/Nextjs) to simple HTML and CSS. Turns out dedicated front-end developers aren't really needed, at least not where I was employed.
• dwa3592 5mo ago
  I have a slightly different take on deskilling argument. I don't think AI is going to deskill. Someone who has spent 10 years working in any field before AI is not going to get lose too much. Yesterday I sat down to solve a medium hackerrank problem without any assistance (code complete, AI etc) and it took me 10-15 minutes to get into that mode but i was able to do it comfortably just like how i used to do it pre-chatgpt. AI might unskill the younger workforce which will enter the field, aka they will never learn the way we did.
  • layer8 5mo ago
    The term applies to the skills required from workers, not to how the skills of an individual evolve over time. The argument is that AI lowers the skill requirements for software development, and therefore less skilled workers will displace the more skilled ones because they are cheaper, as (allegedly) happened in front end over the past decade.
  • alex_suzuki 5mo ago
    i wonder if you’ll still feel the same way in two years. knowledge decays slowly and the suddenly, at least for me.
• docheinestages 5mo ago
  You talk about deskilling. But are these skills even relevant to the ultimate goal of producing a web page according to the design specification? Should we have been worried about the "deskilling" that happened when we transitioned from punch cards to high level languages?
  • MDCore 5mo ago
    Yes they are relevant. From the article, skills like "accessibility, progressive enhancement, network performance, interface design and user testing" are relevant to the ultimate goal of producing a web page. Front-end development is not merely implementing a design specification. The skills listed are relevant to transformkng the design specification into a web site/app that runs on the many devices and platforms and is used by a variety of users.
    • docheinestages 5mo ago
      The design specification can include everything you mentioned. The article argues that "JavaScript frameworks have deskilled frontend development in the last decade." That's what I can't agree with. We need the simplest way to achieve the desired outcome. Using higher-level means to do that doesn't mean deskilling.
• Sharlin 5mo ago
  > A lot of programmers may not know this, but frontend used to be a highly specialized skill, requiring knowledge of semantic HTML, CSS, the differences of various browsers, accessibility, progressive enhancement, network performance, interface design and user testing As someone who didn’t really know that being a front-end dev putatively doesn’t involve thinking about those things anymore, I think that list conflates a couple of different things. Things like the differences between browsers and CSS/HTML quirks, needed to wrangle a document markup language into creating user interfaces, are accidental complexity caused by particular path dependencies, and if they can be abstracted out, that’s a great thing. Accessibility, interface design, performance, and other things related to user experience, on the other hand? Those are mostly orthogonal. A UI framework can raise (or in some cases lower) the bottom in the sense of facilitating reuse of (hopefully well-designed) components, but no framework is going to make your UI accessible or well designed by itself. In the fabled past, frontend development didn’t require you to be highly qualified in these matters – web UIs were simply terrible, mostly. High skill level was not required because nobody expected anything from web UIs beyond the barest core functionality. There was UI programming before the web [citation needed]. In a sense it was "deskilled" because you used a "framework" aka the OS windowing and widget libraries rather than drawing rectangles manually (except in some special cases like games where very custom UI is desired – but those custom controls invariably have roughly 0% of the UX affordances provided by standard ones). Back then, Visual Basic and other RAD tools (anyone still remember that acronym?) were front line of "deskilling", but honestly WYSIWYG visual design is still one of the best ways to create UIs, it’s just rarely done these days for various reasons.
• lqet 5mo ago
  This is something that recently also crossed my mind. I haven't really done frontend developing for at least 10 years know, but I am already old enough to remember the time in the late 2000s when suddenly everyone stopped developing web GUIs by hand and used frameworks, and anyone still writing HTML, CSS, JS and database queries by hand was ridiculed. Job offers suddenly stopped asking for PHP / HTML / CSS / SQL / JS skills and demanded Ruby on Rails and Django and Spring and GWT, later Angular skills. It really feels strangely familiar to me: you could get very far very quickly without any real deeper knowledge and have a working web application within a few minutes. It felt like magic. Then you could customize it within the framework by skimming documentation and googling around until... you couldn't, because you had no clue how any of this really worked internally. And just like with vibe-coded web apps, you could recognize the standard framework web app that was patched together in an afternoon from a mile away, but it very much impressed managers. Amusingly, I sometimes find that developers talk about their go-to frontier model in the same way that GUI developers talked about their favorite web framework ~15-20 years ago. Personification of the tool, even identification with it, frustration that things that worked with version X got worse with version X.1, "I am developing things 10x faster now", "I am going back to writing XYZ by hand", etc.
  • sevenzero 5mo ago
    On the other hand, using frameworks later on was a good attempt to standardize things. Having some homegrown GUI nobody knows how to work with isn't an advantage either. Personally I refuse things that "feel" too big (Nuxt/Next), but like Vue... Currently though, I want to get rid of most Javascript so I'll work my way to HTMX or Alpine type solutions with server side templates. Personally the less tech I use the better, there was a time where you had all kinds of bullshit in a web app prior to even adding a single line of custom code.
    • johsole 5mo ago
      +1 for htmx + Django, really my favorite stack for development.
    • renegade-otter 5mo ago
• olooney 5mo ago
  > undeterministic abstraction I've seen people argue that LLMs will just add another layer to the top of the compiler stack: instead of writing code, we'll use English, and run it through a pipeline: English -> Rust -> ASM -> Machine Code What's one more layer, right? But what the author says about agents being "undeterministic abstraction" shows why that will never work. Compilers rely on a concept called observational equivalence[1] to define when two programs are basically the same; this allows them to make changes under the hood like unrolling a loop or targeting another machine. Now, it turns out we know a lot about how and how not to do this, thanks to a logician named Frege who worked out exactly which properties a "definition" would need to have to count as a definition without becoming an axiom. In particular, that it should be "eliminable" and "conservative"[2]. In plain language, that a formal definition should always be able to be eliminated by rote string substitution, and that it shouldn't smuggle in any extra assumptions. When we talk about things like syntactic sugar[3] or hygienic macros[4], we are basically applying Frege's two conditions to programming languages. LLMs are neither. They cannot reliably or provably go from the prompts they are given to the source code they generate, and they make a ton of implicit assumptions when they do so. There can never be any equivalence between two "prompts" in the same way that two programs can be equivalent modulo some level of abstraction. The whole process of starting from prompts is wildly nondeterministic, which is why the only pattern that works is to generate the code, review it, and test it, and then check it in and use that as the starting point for the next prompt. Which is not to say that LLMs aren't useful for code generation; they clearly are. But they don't provide an abstraction that lets us get away from the details of actual code, and thanks to Frege we can understand why they never will. I can say all this with such confidence because I did once write a wild little Python library that used a bunch of introspection to actually do this[5]. And it absolutely did not work in practice beyond toy examples. [1]: https://en.wikipedia.org/wiki/Observational_equivalence https://en.wikipedia.org/wiki/Observational_equivalence [2]: https://plato.stanford.edu/entries/frege/#ProDef https://plato.stanford.edu/entries/frege/#ProDef [3]: https://en.wikipedia.org/wiki/Syntactic_sugar https://en.wikipedia.org/wiki/Syntactic_sugar [4]: https://en.wikipedia.org/wiki/Hygienic_macro https://en.wikipedia.org/wiki/Hygienic_macro [5]: https://github.com/olooney/fourth_gen https://github.com/olooney/fourth_gen
• pull_my_finger 5mo ago
  I don't think we should blame the LLMs, frameworks and the libraries necessarily. In my own experience, it feels like the real problem is a lot of companies (especially start ups) like to talk about "rapid prototyping", but are quite keen to just keep the prototype as the final product. Bootstrap, Rails, Tailwind, Nextjs and now LLM generated code... great for getting something up quickly with a semi-polished look to demo a thing. The real problem is that we're selling prototypes as products.
• emodendroket 5mo ago
  I mean, maybe it was a "lost decade" from the perspective of frontend developers, but I can't say I'm nostalgic for an age where everyone is handrolling everything from legacy browser support to responsive designs and I'm hoping they have a good understanding of all these things because the average page would be much worse than it is with everyone using these libraries.
• dmarinus 5mo ago
  I don't agree that you don't have to know CSS/HTML when you use a frontend framework. I guess some frontend frameworks can abstract it away but most don't and you almost certainly will run into the limitations of those frameworks and then you still need to understand HTML/CSS
• barnabee 5mo ago
  Front end is mostly an enshittified disaster hiding behind "UX" and "design principles". If LLMs help me never use a front end owned/dictated by a corporation again it'll be no bad thing, regardless of the quality of the code they write.
• Devasta 5mo ago
  People don't use web tech because they care about quality, they target it very specifically because its one of the places where quality doesn't matter. If your native app crashes, your users will curse your name. Webpage or Electron slop freezes? They'll shrug and restart. This idea that quality ever existed on the web is ahistorical at best.
  • llbbdd 5mo ago
    They target it because it's the best distribution platform we have, the tech stack is unified, and managing native apps has only gotten less attractive over time. Chrome, the only native app that matters to most users, re-opens your tabs on the rare occasion it crashes. Most native apps are much less reliable than that.
• euejcidnf 5mo ago
  [flagged]
• volume_tech 5mo ago
  [dead]
• dude250711 5mo ago
  Abusing a document mark up language and a scripting language to make "UI" is not a treasure of a skill. We can move on.
• PaulHoule 5mo ago
  Sometimes I think the techniques we used to build complex user interfaces in HTML without AJAX or DOM manipulation back in the early 2000s are effectively lost, like the techniques used to build the pyramids: insofar as younger full-stack developers have been "deskilled" many of them think you need Javascript to, say, validate forms. Once you are using AJAX and manipulating the DOM the complexity of asynchronous communication is going to lead to something of a similar magnitude as React. Sure you can write document.title="A new title" and not have to bring in <Helmet> but even if you think of front end as "just" updating the UI when data comes in from the server a complex application may need to update several bits of the UI and at some point you need to create some kind of communication or state management bus that handles that. Could it have been done differently? Sure. If there's something wrong with the Reactisphere it isn't that it creates an abstraction which other abstractions live on, but these are leaky abstractions. You could use something like Bootstrap or MUI without understanding CSS if you are making something very simple and don't care what it looks like (don't have a marketing team who cares what it looks like!) but to do pro-level work you can put in front of customers you have to understand HTML, CS, JS and all the the frameworks used in your project.
  • llbbdd 5mo ago
    I often think that especially on HN React is just a four-letter word proxying some broader complaint about the interactive web and that most people complaining about it don't actually understand what problems it solves. In general if you show me the source to any sufficiently complex web app that doesn't depend on React, I'll dig through it and find the analogue to React you built inside it.
• ptx 5mo ago
  The article compares LLMs to Stack Overflow and calls it "a continuation of the same trend", but I think there's a big difference. With Stack Overflow, you got multiple answers from different people with different viewpoints and different approaches, each consistent within itself. You could figure out where the author of each answer was coming from and judge whether they seemed to know what they were talking about. You could weigh the trade-offs and merits of the different answers against each other. With LLMs, you get a single mushy pile of slop, not grounded in any person's actual experience or judgement. It might pretend to offer different perspectives, but it can't really, so it's much harder to evaluate.
• js4ever 5mo ago
  [flagged]
• toyetic 5mo ago
  I'm not entirely convinced the framework comparison holds. In the case of frameworks ( and higher level programming languages ) you are operating at a new layer of abstraction with the specific intent to hide the lower level, that's the whole point of the framework. LLM's don't actually move the abstraction layer. You're still coding in react/python/whatever high level language. Yes you can generate the code using natural language but you still need to understand what's being generated, verify its correctness, and reason about the system it fits into. LLMs don't hide anything they produce the code you otherwise would've written and hand it to you to review.
• CM30 5mo ago
  Isn't a lot of this complexity going away for good reason? Browser compatibility was only an issue because browsers didn't stick to the standards closely enough. It's something that's not supposed to be noticeable at all. And let's be honest, one of the best changes front-end development has seen is how previously complex problems now have built in, easy to use solutions. Yeah you could say it was harder to code layouts when flexbox and grid didn't exist and you had to deal with floated elements and absolute positioning, but the new setup is just better for everyone. Customising select menus used to require lots of CSS and JavaScript to remake the element. Now browsers are implementing features to let you customise default select boxes the same way. Having an element expand to auto height use to involve JavaScript. Now it's something you can do in CSS alone. Creating modals used to involve writing CSS and JavaScript. Now an accessible and efficient version can be done with built in tech. Meanwhile JavaScript frameworks are really just continuing the pattern started by previous tools, like WYSIWYG editors, Content Management Systems, jQuery, etc. At the end of the day, any tech that gets more advanced will lower the skill floor and reduce the need to care about those minor intricacies. Most people don't need a particularly advanced solution to their problems, so whatever system can automate away most of the work will get used for that. It's not unique to web development or software engineering.
• panny 5mo ago
  >writing all code by hand This is now officially a pet peeve of mine. I don't write code "by hand" I write code "by brain." A craftsman who does something "by hand" actually needs manual skills to produce that carved wood thing. Even if you know what you want and know what it looks like, you need skill with your hands to make it happen. Software is not like this. I don't need typing skill, the IDE autocompletes most of it for me. I think about what I want and it becomes reality. If you were using a bare text editor and typing out getters and setters your whole career, sorry, you were just doing it wrong. No wonder you love AI.
• deleted 5mo ago
  [deleted]
• foo-bar-baz529 5mo ago
  I just vibe code the html and css. I review the JS, but I figure if the flow of data is correct, I can just verify the html/css code through manual testing
• Rover222 5mo ago
  I'm allegedly a fullstack dev, often working on fullstack features, but I haven't had to think deeply about much on the frontend all year. 90% of my thought/work goes into backend work. The AIs just handle the FE stuff easily based on our existing patterns. Not saying it's perfect or can't be improved, but it pretty much always "just works" perfectly well enough.
• ai_slop_hater 5mo ago
  > Just like AI is deskilling programming now, JavaScript frameworks have deskilled frontend development in the last decade. As someone who started with HTML/CSS and a bit of PHP, later did Ruby on Rails, and then was frontend team lead of a major Swiss newspaper (Next.js at the time), I’ve seen the transformation first-hand. What does he mean by this? What skills were lost? Writing HTML templates?
  • coffeefirst 5mo ago
    Understanding the DOM. Understanding performance. Understanding closures. Knowing how an event bubbles. Understanding CSS… at all. The effect of this is that people who never learned those things are working with a limited toolkit both in solving problems and debugging. And every so often I get to blow someone’s mind with an old trick :) It’s not all bad though! I’m happy to never build a layout with floats again.
• standardUser 5mo ago
  Honestly I think what is missing is not developers but designers. Or, I should say, designers hired to create competent designs that serve people well and not to instead manipulate users. If you want better front ends - get more and better designers! As for front-end code, I don't expect to ever write a line of that again in my life.
• rglover 5mo ago
  > Just like AI is deskilling programming now, JavaScript frameworks have deskilled frontend development in the last decade. Not to be rude but this person doesn't understand the fundamentals of the topic they're discussing. Frameworks just give patterns and abstractions to build a front-end, but you still have to actually know how to use those things to build a UI. You still have to know HTML, CSS, and JS (assuming you want to do it well, not just slap some junk together). Even with AI, unless you're comfortable shipping a half-working UI, just like programming: sorry dude, you still need to know your shit.
• estetlinus 5mo ago
  > Just like artisans and craftsmen that were replaced by assembly line workers more than a century ago Do you really need to go that far back for a comparison? We no longer need human computers to perform tedious calculations, or typists to draft and distribute correspondence. The simplification of frontend development was never a final state. It has always been continuously evolving through abstraction and automation.
• mock-possum 5mo ago
  Opening with this claim of ‘Front end’s Lost Decade’ then not explaining what that is is infuriating to me, a front end developer - which decade was this supposed to be? How/Why was it ‘lost?’ How did I miss it?
• prontos91 5mo ago
  I had recently needed to build a dashboard builder. Simple one. Copilot created it within minutes. A working even though simple looking one. Several more inputs later i had a working usable one. Came back to it later but my tokens are finished :(. So i had to manually review the code and make changes. Code was around 3k lines in one single file and another 500 of css code. Took me a long time to understand the code and make changes. A few days i had to make another change which changes the way it supposed to work But now without tokens it was very difficult since need to make changes in several areas which kept on breaking. Finally i re-wrote it to my understanding. This was a small part of a large code base. I am afraid what a fully agent coding would look like. How are other developers handling large code bases with ai. Just accept what its providing? I can now understand the valuation of AI companies. Once you go in ai its difficult to go back. You need to spend more tokens just to make it work. Ai companies could train to make their code more obtuse, making users very hard to change manually!
  • danielbln 5mo ago
    You handle large code base by enforcing best practices that should have always been enforced. Proper up to date documentation, strict adherence to conventions and coding guidelines, cross review of deliverables, TDD, and so on. Just whispering "make me a dashboard" into the machine's ear is not how you drive agents to create maintainable and understandable code.
    • prontos91 5mo ago
      So you are saying Ai is a smart/fast auto complete and the actual intelligence is driven by humans? Reality aside it took me a lot of time to just having the version i wanted. But i find increasing frustrating is that solution chose by the ai is not optional, not production grade. Which require even more use if tokens and more time waste. Its good for management but for us difficult to maintain.
• 8note 5mo ago
  kinda funnily I think front end died right when all the folks say that the golden age began, at least for craftsmen. Flash is/was the true time for front end innovation and people making cool unique stuff. html and javascript and usability studies killed all the fun and imagination
• ericmcer 5mo ago
  I don't agree that running a frontend application with NextJS SSR, lazy loading, etc. is "easy" compared to the days where you just wrote HTML, JS and CSS. The level of complexity and the expectations of users are in totally different places. Not to mention there are 1000X as many skilled engineers and you are competing with a global market. In the early 2000s there was very little competition. The skills of workers are loosely going to correlate with the demands the market puts on them, and it is extremely competitive now.
• bilater 5mo ago
  Reminds me of the buggy whip makers https://www.youtube.com/watch?v=JOcz-H5u3Rk https://www.youtube.com/watch?v=JOcz-H5u3Rk
• 65 5mo ago
  There is a difference between a run of the mill CRUD React app and solving specific, complex UI problems. I have been a programmer for a long time and CSS is still the hardest language to master. There are countless quirks and APIs most people have never heard of that solve extremely specific problems. For example, using @starting-style with allow-discrete to use display: none on CSS transitions. Knowing that you would need to use this API, what it does, and how to debug your CSS is a skill that will be hard to replace with an LLM because of the fine grained detail needed for CSS. If you do not know how this API works and you need to use it for whatever reason, and then need to adjust your transitions later, it's probably faster to have real CSS skills than to constantly have to prompt an LLM for you.
• bunher 5mo ago
  What is a bit missing in this discussion is that many frontends are very bad, user hostile or non-intuitive. This has nothing to do with LLMs or frameworks in my opinion just bad decisions of the designer. It is not only web apps or websites filled with e.g slow cookie warnings, terrible navigation, or dark patterns. Also the UX of Android, iOS, MacOS and Windows became at most average but not at all better (many things are just worse, buggy and inconsistent). If I had thought in the early 2000s how we interact with devices in the 2020s I would never have imagined thr mediocrity that those market leading billion dollar companies release and get away with it. LLMs obviously don’t help here since they are trained on all of this. Especially elderly people who rarely use devices suffer from this (and their relatives who do IT support :-))
• mvdtnz 5mo ago
  Frontenders took a relatively simple problem and inflated the complexity to astronomical scales by wrapping it in ridiculous unnecessary functional programming concepts. And just when it felt like it couldn't get any more arcane or complicated they introduced the hooks API. The period 2015-2025 was a decade of frontenders fooling their managers into letting them build their own job security into their web UI.
  • FranOntanaya 5mo ago
    I'm going to say something that is a bit out there, but to this day web frontend still feels like a downgrade in some ways to basic things Visual Basic had in 1998.
    • jrapdx3 5mo ago
      I was having similar thoughts about building UIs back in the late 90s and a few years thereafter. There were a number of tools, I remember using Tcl/Tk to create a GUI scheduling program that was relied on for many years. Later on we had Delphi and numerous others. I suppose building for the web was so much more complicated because the HTML/CSS/JS infrastructure was ill-suited as a basis for comparable GUIs.
• bluegatty 5mo ago
  'Deskilling' is totally fine if it's replaced by people who have skills at a higher level of abstraction. Often - the people who are replaced don't recognize the inherent skills of the people who operate the machines that do their work. But there are often non-obvious tradeoffs. Having Ikea means we can have vastly, vastly more selection and choice in the things we put in our homes. And the 'quality' is usually fit for purpose (just because it's not made of Oak, doesn't mean it won't last a very long time). But when you see a winding staircase or those custom moulds .... well you realize 'what we've lost'. There's always a trade-off even if the net positive is there. That 'externalized craftsmanship' sure does add up though ...
  • empath75 5mo ago
    > Often - the people who are replaced don't recognize the inherent skills of the people who operate the machines that do their work. It's not so much the people who _operate_ the machines as the people who _build_ the machines.
    • bluegatty 5mo ago
      A very, very long time ago, at my first job, the people who used anything other than C were considered 'fake' developers and were resentful that everything was shifting away from C for most things. I felt that :)
• madrox 5mo ago
  Frontend web development has always been particularly vulnerable to changes in technology. The role has mostly been responsible for translating the vision of the designer into code. You could say FEs dive into things like TTFP metrics, but arguably these are all things designers care about too, and if you give AI a metric it can measure on its own it is very good at optimizing it. If FEs want to keep working in this area, I highly encourage them to become excellent designers. Many think they are, but can't quite fly solo without a designer and soar to the same heights.
  • jzig 5mo ago
    Agree and disagree. When did designers become the gatekeepers in what a page should look like and how it should behave? I never liked the pattern of leadership and design throwing a Figma over the fence and the saying “now make it”. Have seen plenty of it in agency work. If anything, AI has leveled the playing field - the onus can fall on both of them to do the doing or fess up that they need the other.
    • madrox 5mo ago
      > When did designers become the gatekeepers in what a page should look like and how it should behave? Since...forever? You may not like the waterfall model, but unless you're at a small startup this is how most software gets made. Even the more collaborative shops where FEs give input on designs, it's just that...input on designs owned by a designer. That AI leveled the playing field is my point. It's now much easier for designers to subsume the responsibilities of an FE than the reverse. You know this is true because if it weren't, designers would never have been a thing to begin with.
• greenchair 5mo ago
  Yep similar to the lost decade that was devops and kubernetes.
• axus 5mo ago
  A generic answer to "Something is causing problems" articles: if more people have food, shelter, family, and happiness, it's good. If they have less, it's bad. I can't really tell, from inside my bubble, which is doing fine.
• llbbdd 5mo ago
  IMO odd to frame this around the frontend and not all of software development. "The Cloud" and middleman products on top in various iterations over the last fifteen years has deskilled literally all backend work, going back even further to like, Wordpress. The remaining challenges are operating at scales that most software businesses would be wasting time optimizing for, and taste. LLMs are very good at making computers talk to each other, but taste describes the fuzzier boundary where computer meets people, and people are much more finicky and challenging to integrate with than computers.
• maxdo 5mo ago
  Great UI cult could be an early pre-ai phenomena , not a lost decade. you will need 100 times less of front end , if any action can be asked or explain in voice, text or video or slides always custom to your request. you don't need navigation complex forms to structure. just text, animation to wait, and a few way to embed more complex structures, like text and basic html with charts. this sounds like "almost ui" but in reality it's not. this is text + some custom visuzalizations adhoc.
• olalonde 5mo ago
  > A lot of programmers may not know this, but frontend used to be a highly specialized skill, requiring knowledge of semantic HTML, CSS, the differences of various browsers, accessibility, progressive enhancement, network performance, interface design and user testing – to just name a few. This would give the previous generation of frontend developers (aka C/C++ developers) a good chuckle. The web was viewed as a massive lowering of the barrier to entry and a "deskilling" of the craft. Assembly programmers probably thought the same of C/C++ developers.
  • mathisfun123 5mo ago
    Every layer thinks they're the most important, most highly specialized, most highly skilled layer. Every layer is wrong because every layer is built on top of the abstractions of the layer beneath. Take it all the way down to the physics and the math and you'll notice that even the set theorists assume some axioms (no one knows what the logicians are doing...)
  • Unit327 5mo ago
    That quote is not from the article and has nothing to do with the article, what is going on here?
    • cproctor 5mo ago
      It's intended for another item currently on the front page: https://news.ycombinator.com/item?id=48321631 https://news.ycombinator.com/item?id=48321631
      • olalonde 5mo ago
        Oops you're right, but too late to delete. Weird that it got 10 upvotes...
        • tomhow 5mo ago
          Just shows that a lot of people read the comments without reading the article :) We've moved the comment to the right thread.
• perry2008084 5mo ago
  This seems to be a contradictory point that requires a tradeoff decision: AI can enhance productivity, but it may also affect the skills of engineers.
  • ai_fry_ur_brain 5mo ago
    It doesnt increase productivity except for people who think producing worthless slop is productive.
• yesimahuman 5mo ago
  I reject the core assertion that there was a "lost decade" at all. I was deep in the frontend industry during that time, and many "use the platform" purists completely missed the reality of what people were building with better abstractions: much more complicated and ambitious frontend apps. These apps heavily used new browser APIs and features, they just did a lot of it in frameworks like React, which these purists despised. I think the era we're in right now is fundamentally different.
• ookblah 5mo ago
  "A lot of programmers may not know this, but frontend used to be a highly specialized skill, requiring knowledge of semantic HTML, CSS, the differences of various browsers, accessibility, progressive enhancement, network performance, interface design and user testing – to just name a few. To distinguish what they’re doing from what “frontend” has become, practitioners of this arcane art nowadays often refer to it as the “front of the frontend”." that "knowledge" we held was to combat the absolute shit that was the browser ecosystem 20 years ago lol. you could argue it was a time of great experimentation and creativity, but no unified ui/ux patterns, adding in css hacks and doctypes blah blah to try to catch all these weird edge cases, if you're still reminiscing that time not sure what to say. today's tooling while also messy in it's own way is 1000x bettter. also i've never in my life referred to it as "front of the frontend".
• namuol 5mo ago
  > knowledge of semantic HTML, CSS, the differences of various browsers, accessibility, progressive enhancement, network performance, interface design and user testing Sorry, but developers from 2012 didn’t have proficiency in most of these skills any more back then than they do today. I would argue frameworks introduced a lot of welcome debate and discussion of these things and actually helped disseminate these skills far beyond the “old guard”, not to mention the pressure put on browsers to normalize behavior and the huge improvements to the JS language born out of the induced demand of the huge rise of web apps that were all but unmaintainable in the before-times. Obviating the need to know about browser quirksmodes is a good thing and we have frameworks, in part, to thank for that.
• ai_fry_ur_brain 5mo ago
  LLMs build terrible frontends, and I won't use a site or product that used one. Its woefully obvious when someone does.
• greeklee 5mo ago
  [dead]
• deleted 5mo ago
  [deleted]
• Natalia724 5mo ago
  [flagged]
• aiisahik 5mo ago
  Anyone who cares about the "craft" and "quality" of frontend or any other domain of programming should LOVE all the LLMs because it actually enables high code quality at very low cost. You can enforce best practices, do full code refactors, write as many tests as you want and you can do it without telling management that you need to stop writing code for 2 weeks for "tech debt". All you need is one guy with a lot of tokens to stay up with a lot of caffeine one night. This is not the lament of the code getting worse (it's not) but the coders losing the knowledge of how to do it by hand without LLMs. If people really wanted to learn how to do things by hand, they can. In fact the AI is probably going to be infinitely more patient and knowledgable than any senior dev if you really wanna do this by hand. Just turn off the AI's ability to modify the code and just have it give you advice on the side. The reason why nobody does that anymore is because most engineers work for capitalists not artists. It's the same reason I don't know how to farm my own food or make my own clothes like my ancestors did. Most people do programming because it's a job - not because it's an artistic passion. And that's OK.
  • s1ngular1ties 5mo ago
    Amen. I feel like I live in a different world than many of the commenters here. AI has made it such that most code “vibe coded” follows our root architectural practices by default. I couldn’t be more thrilled, and watching how enabled people are with this in their hands is amazing! I feel for the people in the thread who aren’t getting or feeling that experience.
• unnouinceput 5mo ago
  I actually love this deskilling. It means your project will accumulate unseen consequences that at one point in the future, several hiring churns done meanwhile, you'll need to hire an actual competent programmer to untangle the entire spaghetti code. And don;t come at me with "but AI will be able to do just that". Yeah, the same way that OS'es kept growing in size with each hardware leap (remember 1 GB XP installation was a shock?), the same way the code that better models will spit out will grow too. And then when 20 prompts later the AI will hallucinate a shitload of new classes, the boss is going to finally be at the crossroads "scratch this and restart or pay the consultant a crapload of money" question. And I will wait just around the corner to be that consultant. For me the future is looking bright actually.
• blakblakarak 5mo ago
  I’m a Frontend Dev - I don’t miss the ‘glory days’ of IE6 and Safari for Windows one bit. Accessibility, performance, adaptive designs, state management and rich UIs are far more interesting and challenging.
• hkeni 5mo ago
  You are onpoint about deskilling. This phenomenon occurred when “UX designers” were replaced. At that time front end developers rejoiced. Now that the front end developers are being replaced, we see a lot of fear mongering and loud behavior as I figure that these are the same people who maintain and contribute to Reddit, substack communities. As for determinism for code abstracted to even high level, I have a theory that if we the AI is allowed to function at the lowest level we human can understand, which would be assembly language, then we may be able to get some determinism back.
• m3kw9 5mo ago
  When I see front end slop, I see that italic large looking font they all use. You all know which
• spriterock 5mo ago
  [flagged]
• terekhindc 5mo ago
  [flagged]
• stephenlf 5mo ago
  I supervise the contributions that juniors make to our codebase. To do this effectively, I use three tools: 1. Scoping. I give juniors projects that are big enough to be valuable, but not so big that they get lost. 2. Instruction. I give juniors frequent, bite-sized lessons related to their tasks. In this, I invest in their skills. 3. Linting. Anything that could be considered a “nit” in a code review is relegated to machine lints. For example, I will never talk about formatting in a code review. That is solved by tooling. This article makes me wonder if there’s some sort of machine-readable lint for costly abstraction? In a TS project, is there some way to say, “the shadow DOM under this component is too deep.” Or “this object’s inheritance tree is too long.” Or for zero/cost abstraction languages, is it feasible/productive to lint “this packages dependency tree is too deep”? How do you identify abstractions that are too leaky to be helpful?
• tomik99 5mo ago
  [flagged]
• frictasolver 5mo ago
  [flagged]