hckrnws

Our QA, formerly a fairly frequent blocker of all our releases, are doing more in-depth reviews and catching issues earlier in our release process. They have become unblocked to the point they are actively chasing down work that starts to slip.

We have cleaned up and tuned both our security alerts and operations logs and improved our tenant isolation in our service in a way that makes customer and formal audits SIGNIFICANTLY easier.

We're setting ourselves up for faster human development of the hard-things. Our development environment and infrastructure are faster, cleaner, more auditable processes, and cheaper overall to operate.

These fixes mostly don't show up in our product change logs, and definitely don't fall into "new features". It would largely be invisible to the outside world, but our costs are going down (though to be fair, not offsetting the spend on AI to date), internal productivity has improved, operational incidents are down, and customer satisfaction is up.

Everyone’s trying to figure out how to convert this speed to product features at scale, but enterprises are like container ships. Lots of might but slow to turn. The littler companies can actually take advantage of this and produce higher quality products at much faster speed. I think you’re expecting too much in the short term and too little in the long term. AI-native companies are gonna eat everyone’s lunch, once they figure out how to actually do it reliably.

For the question where are the alternative OSes? Here is one that I've seen. There's probably more - https://www.reddit.com/r/ClaudeAI/comments/1wfpydl/i_asked_c...

For that other stuff you mentioned like the right click menu. Those huge corporate projects suffer more from layers of institutional dysfunction and will be very very slow to show any improvement. Their dysfunction can't be solved with just faster coding.

Using AI to build more features is easier than using AI to improve existing projects. People will gradually figure out how to do latter too, it'll just take longer.

Scale in headcount was a tactic to get investment, then you had to find stuff for everyone to work on. Suddenly people have the time to engineer so hard that we get runtime JSON defined CSS rendering engines to produce the same buttons we've had since 1995, instead of just writing a stylesheet and html.

Code output velocity from AI threatens to be useful, except it's also prone to over-engineering and burning tokens on the unnecessary. It's learned from the best after all. My suspicion is there is a lot getting done, but it's just not that impactful to flagship products.

As others have noted, there is a lot of new work going into passion projects that would have never happened otherwise, and that is cool. But I wouldn't hold my breath for SV tech to become super pragmatic and effective.

The simplest explanation is that they don't give a flying flamingo about what you or I consider "improvements to products".

This report is an example.

There are several changes that modify CI behaviour, where the article gives no corresponding quality measurement.

They replaced type aware custom lint rules with AST-only static analysis. They don't say anything about what those new rules detect, didn't do old-vs-new rule comparison. They switched the TypeScript check from tsc to tsgo. Again, they are very proud of the performance improvement, but don't seem to care about diagnostic equivalence. The list goes on. They don't even report pass/fail agreement between the old and the new CI. They have 4x more tests, but no idea whether this big test suite works any better than the smaller old one, or even whether it works at all.

The blind community is benefiting enormously from coding agents. Game accessibility mods for everything under the sun (the big names in the last month or two are Civ V and Witcher, although there's plenty more), accessible 3rd party clients for annoying sites, people's favorite speech synthesizers ported to platforms they never ran on natively (or just straight down turned into portable C), plenty of small but nifty utilities and apps.

This is because that community's needs are amenable to what AI can do. Accessibility work (on somebody else's product) is a lot of demotivating and extremely difficult reverse engineering drudge work with a verifiable success criterion, and this is what AI excels at. Large-scale software dev is all about judgment and taste, and here, AI is not doing so well.

You see the same things with mathematics versus medicine. In math, the bottleneck is basically human attention, formal proofs in Lean are, again, drudge work with verifiable success. In medicine, the bottleneck is patients, paperwork and the lab environment, so even an omniscient LLM without the ability to pour fluid into a beaker wouldn't be that much of a productivity improvement.

Github has reported a 14x increase in code. Where did that 14x increase go? Certainly not to providing economic value - as you explained, we've basically flatlined there. It doesn't show up in revenue or profit margins. It doesn't show up in the app store metrics. It doesn't show up in speed or quality or security. It doesn't lead to new innovations or breakthroughs in software problems. All AI coding has done is to create more code.

The disconnect between 14xing code and barely 1.0xing software value is stark. It's not really an indicment on AI coding though. I think it reveals something interesting about the software industry. Specifically, that it was never about the code at all. It's about making that code do tricks in the real world - that's what constitutes almost the entirety of the value proposition. Code is cheap and getting cheaper. Software remains hard and is getting harder.

I've been fixing everything that has been sitting there—not blocking us, but slowing us down—all the things we never had the bandwidth for. We're now squeezing more out of development, CI, and production.

I'm not sure why, but I'm concerned this may be the heyday, and we might not get this again at this price or speed. So I figured we should clear the backlog while we can still afford it and still have the ability to do so.

But now things have changed, and the bigger, grander ideas are starting to brew.

This was never the goal, because it would influence the standards and expectations of the end user. Any gamer remembers when Baldur's Gate 3 came out everyone said somewhere between "this is the new standard in AAA games" or "this is an amazing value for money". The response from the rest of the gaming industry was pretty much "lol no, not really".

Customer satisfaction rarely aligns with C-suite goals. The faster you understand this the better for your mental health.

If customer satisfaction actually aligned with corporate goals then planned obsolescence wouldn't be a thing. Yes, this doesn't apply to software... or does it?

  - Rewrote a data extraction and PDF bounding box algorithm - LLM provided the tooling to visualize the output of algorithm and find the right rules for our needs.
  - Migrated an old SciBERT model that was bundled into a 6GB docker container that needed GPU, with to an ONNX based inference container about 900MB running on CPU.
  - Setup a K3S cluster to replace our Nomad cluster.
  - Optimized an algorithm that used SQLite with better indexes and optimized querying with some 60-80% performance gains.

Now are the end users going to see the benefit and is the product magically better? Well no. The chicken answer is I am not involved in that side to know. But a more realistic answer is, user experience and product fit is not something LLMs can solve. That's still upto the humans to figure out and I think that's where this "nothing has improved" feeling comes from.

A lot of people may be more empowered to create things now with less up front effort but it doesn’t lead to having better ideas or more actual system architects.

AI makes mincemeat of something like Sony cameras, which only have security-through-obscurity. I started my project a week or so ago and I have all the decryption keys I could wish for, and bootrom code execution: https://github.com/DavidBuchanan314/ILCE-7M4-RE/ (Some of the code is hand-written, but only for my own edification)

I haven't even been using Ghidra, I just let the LLM use objdump and python capstone, and it figures it all out for itself.

Doesn't matter where we're going, as long as we get there FAST!

It's a sickness.

It’s not night and day (as you’d expect from the hype), but I see some differences.

I don't know what products you're referring to. At work we rewrote our platform from scratch using AI and our users have been raving about the massive improvements we made and the new features we added (that we previously hadn't been able to due to tech debt and being short-staffed).

We had a major account that dropped us last year because the main feature they were using didn't do what they needed and it had a lot of rough edges. We thought we had lost them forever. Well, yesterday our senior account exec convinced them to sit in on a demo of the newly built product and they were floored. They loved it so much that they're coming back.

Outside of work, for my side business, my users have been raving about the features I have been shipping for the past year. Previously I would work on it casually and mostly address support issues that came up, but shied away from rocking the boat too much with anything too ambitious because it's just me and my spare time is limited. But with the help of AI the product is now more performant, more user friendly, and has a lot of valuable features it was missing before. I've been ten times more ambitious. I know several solo founders like me who have similar stories.

I built a debian based OS focused on self-hosting: github com/onmoose/os It's not really Linux size but I couldn't have built this if it wasn't for coding agents. Still a ton of work needed on UX but the main functionality works so well.

Linux also has decades of work on it, we can't really expect new products to equal that in 2 years of agentic coding

Examples of things I’ve tackled this week:

- GitHub Actions costs exploding and looking into self hosting options (gonna try a box in Hetnzer)

- figuring out how to handle unattended builds

- tinkering a lot of email, from how to manage domain reputation and worrying about bots spamming from my server because they started filling out forms

- figuring out how to manage AI development from my phone

- setting up a process to prevent unintended destructive database migrations

- finding a way to know have to babysit the AI but approving a constant stream of questions and permission requests

- all the random little issues that the AI files to fix an endless amount of little things

- finding the right model(s) to use to most efficiently make use of the limits of my subscription

And so on.

On the other hand, look at the YC companies. I think the last batch or two is growing revenue faster than any batches ever before. Those are the companies that are being sped up a huge amount by AI.

I’m not sure Google, Apple, and Microsoft are the best barometers of AI impact on software engineering. They write software, but at such scale and with such ossified business practices that would expect them to be laggards in leveraging AI.

And things like windows slow context menu are exactly where AI is less useful, because the problem is cruft and the requirment to maintain backwards compatibility with decades of first and third party apps written for older versions. Fixing that is a huge refactoring exercise which AI can do, but which is extremely complex and full of risk.

Same with writing a net new OS: what do you want in the OS? The problem is requirements and market need, not code.

Code moves much faster, product taste doesn't. Once you have your marching orders you can make features 10x faster. Shots off target still miss though. It doesn't matter if your code gets generated 10x faster when it doesn't resonate with users.

But actually coming up with, testing, and rolling out loved new user features. AI isn't that good at that and we can't really "prompt" that out of it as easily as we can prompt a py2 to py3 conversion of old code

Yes. The lack of actual tangible results is how you know that the claims of increased productivity are false. We haven't seen a bunch of new useful apps (or anything else for that matter), which we would have if LLMs actually worked.

we literally do, we shipping feature faster than ever

If you apply AI to low-level applications, it is quite good and you avoid the runtime bottleneck of webness, I have found. Eg. https://github.com/Redrum624/Vitrine is very good but has a horrible UI due to the webby nature of its rendering - all vibe coded. If you used a native toolkit it'd feel completely different.

The quality definitely improved, but our products were usable before, only not perfect. The improvement is mostly on the margin. Instead of crashing twice a week, the app crashes twice a month. A communication session won't fail in two hours, but maybe in two days. (But the average session in the real world was < 20 minutes anyway.) Some UI elements that were not necessary, but are nice to have.

smarter companies are coming up with internal tools that dogfoods on itself which means vendors can't match specificity. but those are the companies where the CTO codes and contributes regularly, and are able to pull the strings across the company to get something like that running

I compare that to the last place I worked where the CTO hadn't coded in decades and was throwing spaghetti at the wall trying to figure out how to use AI. this meant we had designers/PMs shipping directly to prod and but for the sake of a very stressed out Staff Eng and I, they would've force pushed everything with zero testing. but even still, there were TPMs building out a central TPM dashboard to help with cross-team collaboration. and that was largely because their director was very good about getting all of TPM to buy-in, set up their specific configs, and adopt consistent roadmap templates

it all depends on if your leaders actually know what to do with AI or if they listen to some dumbass podcast by a barely-know-anything influencer to drive how they approach things and are looking for hail mary throws

Using the custom interface instead save a lot of time.

Yes, just rehashes of the same thing that was done before, in another language/framework/codebase/fork.

So: while running in circles might be a bit of an exaggeration, it seems (which maps to my experience) these things are much less AGI than reporting might suggest...

Ours is moving faster than ever in terms of feature delivery, and we've used AI to really hammer at the security aspects and clear a load of backlog stuff.

I don't know if it's AI or not, and I haven't liked all the changes, but there have been more of them than I remember before.

the important thing to microsoft is still finding new ways to make money, not to make your clicks faster. they might even be using their new velocity to make clicks slower with an ad in between.

there's alao much less incentive to build things to share. people can just make their own widget app and not need yours

https://news.ycombinator.com/item?id=49248463

If AIs are so great, where's all the great stuff?

What is Switch 2 security doing here? (independently of it having so few features added per update)

Wow. It actually does. I thought you were exaggerating.

Huh? I'm seeing improvements in products _everywhere_. E.g. Linear. My team has been a heavy user of Linear for years. They have shipped a huge amount of things in the last 6 months, and the gaps between major changes is dropping.

It is twice as useful for our team as it was last year.

I'm genuinely impressed.

On a serious note, it might take a while to realize the actual benefits or losses. Its clearly not a good signal when people whose job is to manage other people start writing their own pet AI projects. This just indicates that AI has created this big job insecurity among everyone. At the end of the day being an engineer, eventually the job is relatively safer when there is so much code being written out there.

For a less complex project (1 programming language, still shipping to all 3 major OSes), with my knowledge and agents I got the bazel conversion done in 2 weeks.

The setup cost for bazel just went down by a lot, and I don't think the industry as a whole is aware of that yet.

Mostly around, at least the majority of 'stuff' I've worked on (both before and after the rise of coding agents) myself or others took enough time to make sure that anything done locally, if you run the tests locally, you're at least 90% of the way there as far as what CI/CD does.

I suppose the flipside being, most of those projects had less churn (i.e. one person was working on a service at a time, and we had good contracts between services.) Also, Our local boxes were way better than our CI boxes, so there was incentive to run locally versus waiting 2-10x the time for CI to run...

    > where sub agent orchestration is done through agent to agent messaging

Genuine open question here. My assumption is that a GH or Linear or Jira is still useful as a decision store. It may as well be a custom app over Postgres, but it seems like something is needed to store this and for observability. A GH/Linear/Jira is nice if only because of standard APIs and integration points (whatever you build would likely end up duplicating a subset of those).

Why not? A good chunk of software engineering problems can be solved if we re-structured our definitions. Even just a year ago, people did not believe that a good chunk of prod-running code would be completely AI generated. Now we're at the point where some companies try to split "what code has to be PR-reviewed, and what doesn't have to be" to remove that bottleneck and so on.