If you're not finding it hard to write software any more, write more ambitious software.

I'm taking on massively more ambitious projects than I was just a year ago, and it's taking every inch of my skill and experience to do that.

Building software feels harder now, and I'm really enjoying it.

What type of applications are y'all seeing from LLMs? Anecdotally the only thing that has changed for me is the ability to output more code. That's not software. My coworker is a 10x vibe-coder and his flagship application is held together with brittle shell scripts, a sloppy codebase, bad abstractions, piles of markdown files and an ouroboros of generated tests. This is not software. This is just held together with duct tape and a prayer. Although this guy doesn't have any traditional background but still, if LLM generated coding agents were so good even a simpleton like himself should be able to create a miraculous piece of software, right?

I remember C compilers becoming affordable, and GCC actually getting good.

I remember Java coming along, and how much easier it was to build compared to all the crazy linking and cryptic error messages my C compiler gave me once you went beyond a toy program. And god forbid you wanted it to run on BOTH Borland and visual C!

I remember CGI, and then PHP making it trivial to write web apps, and then less trivial webapps, and then webapps that people actually used in serious business.

Then I watched the same thing happen with Javascript.

All those rebuilds of the same foundations, making the same fundamental design mistakes again and again like a wheel of karma, but with prettier UX and less vendor lock-in.

And now, AI makes it even easier to re-make those mistakes. It's gotten "easier", but it's actually gotten harder. Making something that runs has never been more trivial. Making something with a solid architecture and disciplined hygiene has never been harder.

And so we begin round 4 of re-learning the lessons of the 1960s-1970s.

TBQH it used to be easy. I remember watching one person with Access set up dashboards that worked 1000x better than all of the dozen SAAS tools no one can wrangle together today. Small businesses pushed updates and menus from Frontpage. We used to spin up quick code on our calculators, meanwhile our much more powerful phones act like executing our own code is an act of terrorism.

LLMs (maybe) get us a little closer to closing the complexity gap and making our personal computers personal again, but with the funny problem of needing to use someone else's computer to do so.

Maybe it’s just me but it’s still hard. Writing code wasn’t hard before. Honestly putting up guard rails is harder than writing it yourself. It just may be faster now.

Getting proper requirements, knowing what to make, update, the domain knowledge, satisfying customers was and still is the hard part.

> Turning this essay into a song in the style of 2000's Hip Hop? It used to be hard

Have you listened to the song he links? It's very convincing. If you were just casually listening to it in the grocery store, you wouldn't notice it was made by AI.

I disagree that something becoming easier is a negative, even if it sucks for the people who learned the hard way.

The real issue is that the floor has been lowered, but the ceiling stays as high. It's always been a problem in this profession, where you can get something running much easier than you can make something safe, maintainable and ethical.

We keep making it easier and easier to disregard those extras. Both technically and culturally. It's not a good path.

Hard is relative. The Apple IIe could do roughly a half-million instructions per second. Yet, application develop was long and tedious. Layers upon layers of abstraction requires more powerful CPUs, but translated into highly complex applications and user interfaces. What if we could use the LLM tools we have now to go back and see what is possible with older machines?

For example: The Python print('A') statement translates into thousands of lines of assembly (using mostly compiled libraries). The actual minimum assembly to generate a print statement is less than a hundred. Claude code can do this:

>>Generate the minimum amount of assembly code to obtain the same result as print('A') in Python.

The result is 43-bytes of machine code (it works, unsurprisingly). Claude estimates that Python requires 5 megabytes of compiled libraries to get print('A') to work.

> This might be why despite AI automating so much work, the 996 grind culture is more alive than ever.

There's an interesting paradox which occurs when a particular field finds its work becoming easier. Suddenly, the world needs more of everyone else's job and less of your job. You have to work harder now that there's less work to do, because there's more competition.

It's maybe much easier to create code, but it's still hard to create good software, and for the next few years we have a monumental challenge of figuring out how does one create good software when cost of code is approaching zero. It will be harder to decide what to build (or what to not build), increase the velocity, even if only for infosec patching, make use of increased velocity for features, massively increase experimenting capacity, and close the biggest loop. Even the best teams now are barely scratching the surface of what tomorrow brings, and it's super exciting, interesting and definitely not easy. It will be hard, but not in the part that was hard before.

I think emotions are an underrated aspect to the "AI changes how we work" thing. Everyone I know extensively uses AI in most parts of their work. Basically everyone has multiplied their output by a lot.

But I don't know many people who say they enjoy their work more because of AI. I definitely resonate with the pain of watching something that required so many little bits of knowledge you earned over years melt into pushing a button.

I might just be the artisan cobbler watching factories rise during the industrial revolution. Making good boots was and is still hard and requires a lot of specific knowledge, but the amount of people appreciating well-made boots plummeted as factor-made, cheaper boots flooded the market.

And I know, rationally, that the line of "what is hard" is just moving. There are great industrially-made goods the same way there are great products whose code is mainly AI-generated. Like good boots, building safe, scalable, distributed systems is still hard.

But I can't help but have some nostalgia for how things were pre-AI. Work felt more honest, the skills I spent years building felt more valuable, and I was more satisfied at work.

I think it mostly got harder? You had relatively clearly defined paths to build a skill that would be valuable. And now you don't. So the skill that you need to learn now is, roughly, figuring out what to do when nobody tells you what to do.

I think the hard problems are still hard.

I think the problems used to be easy and here we are.

I disagree with the article a lot. Solving problems because easier yes, the size of the problems became bigger. What I can do now with an LLM is magnitudes larger than I could've done alone.

Its still really hard to build large, secure and maintainable systems.

idk how many articles I have seen as variants of this but

what you do when things get easier is... go try something more difficult

If before it was hard to build one software thing

And now it's easy but building 10 software things is hard (or some other kind of new software thing)

Then you build the 10 or new hard software thing

Satisfaction restored?

I read this blog post and the authors other blog posts. They give off a strange vibe to me.

It's almost like a reverse doomer-doomer-ism. I'm terribly sad because others don't see the value in this thing I grew to value. It is very New York hipster.

What will always be hard and useful is to observe people, find a problem they haven't solved, and then solve that problem for them. AI has not, and will not, make that easier or less useful.

All these analogies are just bad. If we are going to live with LLMs, let's reason from first principles. 'It feels like we're just going to be left with analogies'.

> I legitimately think this will be the biggest sociopolitical issue over the next few years. The frustration of seeing your hard work getting one-shotted.

Man, what a narrow world view.

> I feel like an old rock and roll guitarist watching a DJ sell out a stadium.

Now it is too easy. I started garage band with my flatmate, we sell out stadium every weekend. Single ticktock short gets us million views.

Why people complain today? Just live celebrity life!

Very limited thinking about challenges that are derivative to this time in history.

These used to be hard things that the author listed, and a potential next evolution from 1 minute of abstract thinking on my own:

1. "Building a financial model to compare recent S-1 filings?" - Build a bigger model to do a larger and hopefully more accurate/conclusive model.

2. "Photoshopping recent presidents onto Mount Rushmore?" - Make a physical model of recent presidents on mt Rushmore.

3. "Turning this essay into a song in the style of 2000's Hip Hop?" - Make a song that people actually give a shit about.

Like cmon folks, none of these seemingly hard things were actually all that useful for humanity, but rather just a task that was put in front of us because of the environment we were/are in.

Pre and post ai-boom; most software I interact with is dog shit. Not much has changed there other than speed.

Wtf, it's still hard (wo)man, or are you just dropping your vibe coded stuff onto your customers and call it a day?

I for one still understand what I'm making and strive to be able to converse about it intelligently with anyone interested.

Of course I also use LLMs all day, but it's not like anyone can suddenly do my job to the same standards.

This is simplistic. The hard part of writing professional software has never been the code.

All the remaining problems still exists and I dare to say they were made worse.

I have bad news about the demand for DJs.

the 0x engineer became a 10x vibe-coder responsible for our CICD and vibe-coded testing that was previously manual

He's introduced several 100,000s LoC changes and additions in 10-15 codebases. There are some repos that only he works in ( so no PRs, just merge to master and be done ). He also has self-approved and merged changes without review (he's an admin)

Anyway, now he put in his notice and no one on his team knows how any of this works. We can't get code changes without CICD passing. CICD breaks all the time. The original contractor who made the CICD before him wants nothing to do with it now. We can't generate signed OTA packages.

He went from doing 'too much to finish anything' to 'made so many changes that he had to bypass PRs'.

Now he's leaving.

Engineers have been pointing out this bottleneck for the past year or so. The engineering managers aren't pushing it and the business owners either don't understand or don't care

Software has, with precious few exceptions, almost always been held together with duct tape and a prayer.

> brittle shell scripts, a sloppy codebase, bad abstractions, piles of markdown files and an ouroboros of generated tests. This is not software

I think that's software. It's not good software, but it's software.

This perspective feels a bit like a chef insisting McDonalds or frozen dinners aren't food. It's mass produced, unoriginal, and typically soulless, but it's still food. As Scott would say, maybe a map vs territory discussion.

> his flagship application is held together with brittle shell scripts, a sloppy codebase, bad abstractions, piles of markdown files and an ouroboros of generated tests

you just described lots of codebases at highly values companies. Plenty of places, maybe even the majority, do not care about code quality if the code results in a functional application.

I built an orchestrator connected to email, browser and payments, and it handles a ton of boring stuff like “pay electricity”, or “apt renters want something, deal with that”, or scheduling appointments, dealing with infoline chatbots and everything around that.

Plus navigating personal communication (what’s the address of friend X, who did I promise to go to a dance workshop with) and so on…

In essense, anything Siri promised to be, but really working.

I enjoy my work much more with AI. My least favourite parts of software engineering are the parts that AI is the best at. Never again will I have to manually insert ten debug statements, or git bisect to figure out where an issue started, or fix a dozen merge issues that are obvious but tedious. These aren't even the thinking parts of AI, though I do use those too. Just the mechanical tedious work that Haiku could do make my workday so much easier.

“But I can't help but have some nostalgia for how things were pre-AI. Work felt more honest, the skills I spent years building felt more valuable, and I was more satisfied at work.”

I am 25 but as someone who came into this field very passionate and competent, this was my initial reaction and it sat uncomfortably with me for many months. I still have nostalgia (mainly from a younger age). On work feeling more honest, I think this is a result of an institutional attack on software engineering rather than a new reality of these tools. Like what happens to many other labor forces in history as you mention with artisan cobblers. In some ways it is a consequence of technology but it definitely also weaponized to hurt labor and consolidate power.

In the case of AI-assisted coding, this manifests in a culture of distrust and disrespect toward engineers, both from the bottom-up and top-down. Managers will devalue their engineers by using AI to bypass them. Peers and reports will use AI to exaggerate progress in lockstep with management. No is no longer an easy vocabulary choice when dealing with power because previously technical prowess was definitive, now it can be made “advisory”. I think this is very wrong and stupid but the market can be irrational longer than you can be solvent or something like that.

I still think it is though, that technical knowledge is still supreme. Maybe this is a cope but I find AI tooling very empowering (minus the walled garden nature of it which can be mitigated through local usage but this is problematic in its own regard). Management, pundits, and tech CEOs can frame it however they want but I feel more technically capable than at any point of my technology journey. Not at work, not in academia, but objectively from me knowing myself. We can do more in less time if we know what to do.

The problem with this thinking is that every shoe cost effort to make. Software takes that much effort to make once, and then it can be duplicated for free whether it's awesome or crap. It isn't the same economics.