To me, true "AI-native" engineering will be one where questions regarding how humans will do things like review code are irrelevant. You explicitly throw away any concept of typical software engineering and, instead, differ to the AI. Your job, as a human, is solely to do what the AI can't physically do. That's not the same as closing gaps between what AI is currently capable of doing and what you'd need it to be capable of doing. It's literally enforcing that anything an AI is able to do is treated as correct in itself, and you, as a human, only support it by being a human.
If that sounds outlandish, that's because it is. We don't have such capable AI systems yet. It's possible we never will. But that's beyond the point. The reality is trying to make an "AI-native" engineering org by just layering AI on top of existing processes and systems is futile. If your expectation is that AI will continue to improve in capabilities at an accelerating rate, then these stop-gaps are pointless. You might as well just ignore AI altogether until it is able to completely take over, because that's the inevitable goal, right?
If you're willing to buy that will be possible, then my guess is that it will occur in the form of small scale startups and actual mavericks rather than someone trying to run an existing business who will simply be too risk adverse to go all in when the time comes. Some guy in his basement is more likely to leverage AI "properly" to build an actual "AI-native" engineering org because that person won't have much to lose.
FWIW I think the company writing this post is one of those small scale startups. But that being said, you're not the only one who thinks this. A decent amount of VCs and funds think that only smaller, newer companies have the potential to be truly AI native because there's too much organizational inertia in an existing business in keeping its existing human processes and so only a newer company can achieve the true "scaling potential" or using AI to scale without human labor.
Most engineers are working in "normal" engineering orgs, but can feel the ground underneath them shifting, and companies believe that if they are caught flat footed, they will be out competed in the marketplace, so they are all trying to make sure they are adopting it at least in a way that lets them keep pace if not accelerate revenue.
If you are not impacted by economic incentives, you can continue to not care about this transitional state, but most people do.
But we're a tiny baby startup, so things like "spin up a new product with 1 engineer and get to $1m in revenue on it" or "reduce our IaaS bill by 300k/yr" is a meaningful contribution for us.
We're also building new AI-enabled software that was not possible before.
The big breakout hits have been AI Infra, but that makes sense from a technological perspective, Cisco made a lot of money well before Google did, but Cisco is not where the money concentrated in the end.
We don't really know what the equivalent of Google as an application business will be in the AI era, but there's a pretty big chance it's not actual Google. But Google still has to do it's best to hold on.
Does not apply to everything though. E.G: I don’t care about AI support for my non work chats/email, since I’d rather not give it access.
https://www.nytimes.com/2026/04/02/technology/ai-billion-dol...
https://www.businessinsider.com/medvi-ai-weight-loss-million...
A company which proclaims they are "AI-native" isn't actually interested in engineering, they are trying to ride the hype wave. Companies who care about engineering just... do engineering, and don't make a big deal out of whether they are chasing trends.
"If that sounds outlandish, that's because it is. We don't have such capable AI systems yet."
That means we are already 6-8 months in, and not far from having a full year of experience of what that actually looks like, albeit weirdly influenced by the increase in model capabilities during that period.
I'm looking forward to those retrospectives. Did this turn out to work OK for the teams doing it? What were the biggest failings and/or surprises? With hindsight, did this produce good quality software?
So far AI works great at fast moving work which you will probably recode or throw away in a month or two anyway (e.g. a startup) but is weak at maintaining a large code base that you rely on. At least part of this is cultural, as the cost of misalignments between team members can be quickly translated into broken software.
> Will we converge on a bug free state?
I have never witnessed this state in my two decades of software work. Why would we think AI will magically achieve this?
When I worked on Guild Wars every server or user crash went to a shared inbox and was bucketed so we could identify and act on new crashes. IIRC we maintained very, very low production crash rates and could prove that many of the crashes were due to hardware faults.
Similarly, Mozilla tries to analyze and act on every crash report they get in the field. If a webpage visited by even a small % of the customer base was causing crashes, the team worked to try and fix the crash to deliver stability. If it was a high-traffic webpage it got treated as a high-priority task - I remember Farmville breaking was basically a 3-alarm fire back when it was extremely popular.
"No bugs at all" is an even higher bar, but it probably is possible for simpler applications with the use of stuff like theorem provers. I'd love to see someone try it in production but I think the return on investment for that is probably super super negative.
The idea that every crash isn't acted on is kind of a crazy one, to me. Not every crash is actually actionable in e.g. a mobile app, but every one should at least get an eyeball in my opinion.
This, to me anyway, is the bare minimum of "caring about software quality". If you do this regularly you'll have very solid code, and it's interesting that I have the perception at least that Guild Wars was a quality product.
There's another layer, where you do that for subthreshold issues like UI inconvenience, etc, but that's bonus, I think.
It's a shame, though, because I believe there is a lot of potential there.
I mean, quality is easier with the right tooling (monitoring, linters, property-based tests, theorem prover...). But, given limited resources, it can feel difficult to prioritize investing in quality when business is pressing devs to ship, ship, ship.
But now the cost of writing custom tooling has changed. These custom tools might be sloppy because vibe-coded but we wouldn't have them otherwise! Or we might finally have decided to make that investment after too much time suffering from their absence. Now the cost/benefit changed, so why not invest now?
There’s a lot of good tools out there that are not used, either because of ignorance of their existence or lack of expertise. An hour of config can pay real dividend later.
And sometimes you just use some unix utilities and hack a bash script while testing things out.
Earlier, I reviewed code that does way more than specified scope, changes public API and introduces new behavior. I had to almost redo the whole thing.
I thought to myself, no way I am going to ship the code as written without actually reading through it (or as some people put it, only looking at the "intent"). I'll get more complaints from users while having absolutely no idea what's going on with the code or actual behavior.
It's a puzzle to me how these orgs can pull it off.
For example: A few days ago I saw a quote that over 90% of current Y-Combinator startups vibecode their products. The problem is the author misunderstands context: Startups sacrifice quality for time to market. In other cases, if you're building something that isn't technically challenging, (because it's 80% similar to many other products out there,) you can probably vibecode it.
In contrast, if you're doing something technically challenging, it's to your benefit to be a lot more hands-on. I recently started getting excellent reviews from copilot of my hand-written code. (Or, I should say, the hand-written parts of an AI-assisted pull request.)
On the other hand, some things are incredibly product intensive and poorly defined and it seems LLMs will latch on to an arbitrary direction with much lower success rate.
It is also worse in "brown field" where there's lots of tribal knowledge and technical debt. Two systems may both exist that look very similar but oftentimes there's the one on life support that almost no one uses or cares about and the LLM doesn't know it should largely ignore that until it's thoroughly documented (which can be a significant undertaking)
The rest are just marketers.
[1] Whatever that means to them
> no way I am going to ship the code as written without actually reading through it
Interestingly agents can help, not replace, this process
These tools will make us more productive, they will disrupt (have disrupted) our industry, but they will not replace us because they cannot
What works: - Empowering engineers. Giving engineers more trust, ownership and product decision-making leads to more engaged engineers vs. micromanaged tickets. Engineers who are treated like owners tend to notice cross-cutting problems and push to get them cleaned up. - Hire for diversity. Not race or gender, but diversity of thought. Different ages, backgrounds, approaches to AI, focus on frontend/backend, etc. Race/gender diversity tends to come along for free. This is a huge edge because every LLM is spinning up the same next token prediction, so approaching problems from different perspectives gives more robust coverage across your codebase. - Flat org structure, low ego. Interns and 20 year vets work side-by-side and teach each other things - hire for openmindedness. - Communicate about product. What should it do? How do we want a feature to work, and how to handle certain edge cases? If the product is well understood, the code follows. In-person/hybrid is valuable. - Architecture matters more than ever, but it is easier than ever to fix. Listen when engineers mention tech debt. Notice when a simple change touches 27 files. Senior engineers shine for this, because they tend to have a better nose for code smell. - Reviewing still matters. Anthropic may throw tokens at reviewing, but it is a great way to share ambient product/code knowledge across the team. 200 engineers throwing code against the wall is chaos and leads to YOLO codebases. You can move fast AND keep a rough mental model of the codebase intact.
It describes a team spending 30x payroll on tokens - $3,000,000 in token spend per month - building a multiplayer game where incidents and bug reports from users are passed directly to Fable 5/5.1 agents who then act on them and deploy the changes to production.
"We consider it an outage if we don't ship every hour"
It's worth reading because it's either a complete disaster or a glimpse of the future, or quite possibly both.
But is the outcome good? Is the game fun?
at least thats my read on it. i dont know how else to understand whats going on here.
> i dont know how else to understand whats going on here.
As a product that I would regularly use, Pluto missed the mark for me. As a SWE in 2023, I couldn't meet Jacob's mentality. Today, it's how a lot of us ship software.
I didn't love the product but I have to respect the process: he was able to sell his company. For some, what he did is success.
We make 10+ gameplay changes a day in our custom kitchensink mod that steers everything. 70%+ are bugfixes (we have plenty of mods that conflict/are buggy), the the rest are QoL improvements, small new features and rebalancing. If we see some playstyle is too strong or boring, we spice it up the same or the next day. Mobs too weak/strong? Update the same day. A ton of performance fixes with actual in-game benchmarking. All this while I keep playing.
I built sort of an automatic modding pipeline (including public release and all) with parallel test game clients + servers used by LLMs to develop and test the changes and then merge before releasing a new mod version. We have had very few issues, I'm still shocked how reliable this is. They follow guidance well and test everything in real game clients on wipeable clones of our live world and our actual characters. Josh has a bugged chest at his place? The LLM will reproduce it, develop a patch, yes, but then also log in as him to his actual in-game base and test the fix using game inputs + OCR. At the end I get a .html page report on each change with screenshots and technical details if I ask for them. I don't care if it takes 4h to do a simple fix because it's not my time and game stability is critical. And up to 8 of them can work in parallel, so there isn't a bottleneck caused by excessive testing/re-testing.
I think this will be the future of gaming for many sandbox/easily moddable games. It's a bit too technical at the moment for regular players to handle the updates and models' quirks, but we're only going up from here. Just crazy.
In the instances where they were able to detect it. How much do you think they pour over individual traces nowadays to search for these things?
But the process is slow. The user wants to add a feature to their app so they ask the AI. The AI has access to a terminal where it can clone, fix, and push. This takes time and isn’t instant.
Once AI can abstract this part, software will change forever. It’s what this post alludes to, does code, PR, etc need to reinvented for this?
Once so, no one would ever use cookie cutter software because you could build your own and maintain it using just an agent.
One would argue that the effort to build and maintain it is why we have cookie cutter software, agentic built or not.
Before AI, the businesses that used Zapier and automation were able to pull ahead of businesses that were still doing things manually. A business that has a custom built software with an agent that can change it on the go will provide even a greater advantage.
And it's devouring tens of millions. I know what tens of millions can make in the video game industry, it can keep a small team of good devs and designers and artists making something special that's _really_ enjoyed by tens of thousands of people.
We don't want more games, we want more great games. This will never, ever, make great games.
Look on ye mighty, and despair. I really don't care how this sausage was made because the only thing you need to know is that it shouldn't ever have been made.
These people have no idea what good games mean.
> They are making spam games.
Edit - after writing "we must be following the same folks" I realized that you are, in fact, Simon Willison - I saw this article because you posted about it on X, haha.
Do players like it?
Will the history of gaming remember this game?
The more agents you throw at something, the more they collide. Those collisions generate more slop, which requires further slop processing agents.
I giggled on that one. It feels like children playing having a job. If they pay that much for tokens they have to have at least 80k customers paying 50$ a month. Seems huge for something like that. Or they have a lot of investors. Anyway does not feel like something going anywhere.
Isn't there a point where you're shipping too fast that the product hasn't even caught on enough yet to know what to build?
I looked at some of the games and it just looks like a Roblox clone
In the past when working on agentic stuff I've observed models gaming checks aggressively, to the point that when we were validating log files to see what the agent had done, the agent responded by editing the log files to pass validation. I can only imagine how bad that kind of behavior is at scale, and it sounds like they ran into it.
I really mean this. Does it benefit the business? Does it benefit the users? When you optimize for the wrong thing, you inevitably fail.
If that's the benchmark, developers are incentivized to produce over-engineered and bloated code.
Software quality was in terminal decline already, the only hope is that LLMs get good enough to dig outselves out of the several miles deep hole that has been dug.
This is the reality I think for a lot of orgs and is absorbing a lot of the productivity gains. The gap between vibe coding a green field app from nothing which is inherently "AI native" and implementing AI tooling into complex orgs with large amounts of legacy infrastructure, integrations, ingrained practices etc is enormous. For us, it has been a big effort to enable agentic coding over a significant footprint of our codebase. And all this is happening while the plane keeps flying, with near zero tolerance for defects in critical systems. There is a lot more to it than you will understand if you just look at twitter or Hacker News.
As in this story we blew enormous effort optimizing something that was very difficult and because of our blinkers (and our management's blinkers) we missed that it was only able to achieve a limited result. We didn't look at the whole system. In the end it was never fixed because......siloed thinking...or something.
> None of this was free. Through the summer, much of our engineering effort went into tests and tooling, and customer-facing changes per engineer stayed between 17 and 30 a month.
What it cost you is that you helped the AI labs become better engineers. At a certain point the Big Flip will happen, and the AI labs will stop their offerings and instead start competing with the engineers.
I don’t think it will ever reach such a point.
First you take your Blendtech and "will it blend" your engineers, then upload the result to the cloud inside what is called an S3 bucket (don't forget to set access permissions on your buckets kids!) to be digested by the clankers, sit back and profit!
Dark humor aside I think disconnecting a bunch of problem solvers from their computing equipment could really enhance the world, putting that analytical power into the world in person could move a lot of cogs, rather then marshalling JSON.
Sure MS, Meta, etc, are still laying off engineers to have money for data centers. But I am 99.9% sure that they will thoroughly regret that move in less than 2 years.
>> Every time we sped up one step, work piled up at the next... we started going through the entire process of shipping software, one step at a time...
I feel like I'm being gaslit here. You can become CTO with this lack of business fundamentals, and a basic misunderstanding of systems engineering?
> You can become CTO with this lack of business fundamentals, and a basic misunderstanding of systems engineering?
(in fact it may be a requisite ...)
When asked about "customer satisfaction" we were told, awkwardly, that became "political"
The paradigm did not survive its encounter with reality, and I do not think this one will either
The "only" 175% increase in productivity is very impressive, and seems realistic to me, when you remove the chores of writing code (thank you to coding agents)
What you build is still very dependant on what you need, and you do not know that until you build it
It is a paradox only for the "waterfall" paradigm. We rejected it, in the 1990s for a reason
It did not work
Only three metrics went up: LOC, token spend and presumably release speed/frequency.
What's the markup (profit/COGS)? is it up?
Customer satisfaction? Is NPS moving one way or another?
These new tools only exacerbate this issue.
The key is to understand that computers exist to serve human needs, and the less code / UI / hoops to solve a problem the better, and to think end-to-end. If you are able to do that, most systems built by committee have a lot of low-hanging fruit that can be improved without much sacrifice. In practice, political realities and operational concerns may come in the way, but I firmly believe this is the only way to successfully operate as an engineer, and it will only become more important in the age of AI.
I push "money and data are sacred"; if we lose either of those, someone cries. Build the platform slow and fast. Governance, scaling etc sits here.
Provide reference APIs and let the product team one shot whatever they want and need, build fast and experimental, but your platform enforces constraints.
Best of both worlds (though feels like we're back in backend vs frontend development)
this is extremely true, but it seems less and less like anyone wants to invest in a solid platform and just wants to jump to executing fast and unsafe. and then pretends that ai can definitely do both when the experience is quite a bit different.
The demand for new features come from sales and executive people who want to check more boxes on a customer's checklist.
Management/Product/Product Engineer - When you are responsible for getting the work done then you look for any and every option to speed it up.
Owner/Platform/Senior Engineer - When you are responsible for ensuring it works and can be maintained then you have to pay attention to how to build it, aka the trade offs
Just because it has the power doesn't mean it should be used.
I'm not asking for everything to be some sort of beautiful code whose concision would lead Knuth to tears. I'm just asking that you not slather dozens of existing functions with three new parameters and dozens of lines of code each that basically do nothing, to cover a use case that I accidentally vaguely alluded to, if you read my prompt a certain way, but isn't really what I was interested in.
Training for good taste in architecture actually causes premature optimization at high effort allowance, but at the same time, it is combined with an inability to even recognize / exploit that later if it should ever become actually useful. Dial the effort down, and it skips the reasonable abstraction and nothing is dry, factoring is insane.
Goldilocks for simple stuff barely works with frontier models after they are out of their comfort zone for topic or line limits.. you kind of just have to decide whether it’s worth it anyway. In practice.. constant supervision for high quality code, or such high quality system design that the code quality is less of a down side.
I think AI has been a net positive and has been used responsibly at my work. It can be used to make existing products better and more secure. You just won't naturally hear about that. There's some challenges like emerging social mores but overall good.
It always works best when layering on top of good human code. The thing is, you start to run out of that as you lean in. Tricky.
Hell, if the Dunning–Kruger effect is to be believed, it would be bold me to assume I am capable of good human code. Maybe the average is the best I'll ever get.
I think it depends how you lean in. I generated a few thousand lines of Rust code today. It was actually pretty high quality. On my initial review, I only identified one change I wanted to make.
Most functions were pretty short and well factored. I wonder if using Rust as a target helps, because (1) the training data doesn't include all the terrible Javascript and Python etc. found on the internet, and (2) Rust and many of its libraries encourage good architecture - code factored into traits, functional pipelines, a powerful type system, etc.
LLMs trained on bad code for mediocre languages naturally write corresponding quality code.
A big part of it still boils down to prompting - what you're asking it to do and how much freedom you give them. If you let them make all the architectural decisions, you're likely to end up with issues.
Why? I keep asking for examples of LLM being used to make code more simple and elegant (which I would say is adjacent to making software better, if not more secure), and never get a reply, not a single one. I'm not claiming it doesn't exist, I know it must exist. If only via a lots of careful massaging of system prompts and harnesses, even if it takes too much effort to be worth it, I would like to see it.
Of course people can't share internal examples, but this is all over the world for many months now, where are the open source examples? Not "something new someone couldn't have done before", but someone making their precious even neater (while also adding things to it, but not primarily). Put differently, can LLM delete code, can they curate it well, can they not write weird comments nobody wants or needs, that sound like echoes of the user prompts and responses to them, but just explain tricky parts of the code, like a human would?
Also, IMO a VERY useful thing to learn about a tool or a chemical or whatever is, "what happens if I keep applying it to the same small thing over and over?" -- because that's the level of scientist I never evolved past, the kind of stuff you do as a kid -- , whereas a lot of this seems to be more about how it feels to apply it here and there until it looks good, and then move on and never look back. Which really isn't much at all, especially given we're such a short time in. I mean, how useful were mugs made of lead? Are people aware of the (in hindsight) insane things that were done with x-rays as those were invented, before the potential for harm was known? I bet they had a great time playing with that stuff, for a while.
What if in 5 years it turns out that a few years ago, LLM got into this habit of implementing certain things in a certain way because it seemed the best to "them" (the training, whatever), but there's a security issue with that -- what do you do? You can only let more agents loose, and hope they don't miss anything, because you cannot even do something like "patch PHP" (which is not my thought, Casey Muratori mentioned that in on of those podcast things).
Fully leaning into LLM doing as much of the coding and understanding as can be handed off to them seems insane to me, I don't mean this to offend though. It just does, like suggesting we go to Mars, because everything is better there, and to do that, we have to blow up Earth. Or saying to magically be able to fly from now on, we need to saw off the branch we're sitting on. Even if I thought life on Mars was the future or that we could fly, if we just thought of it the right way, this isn't a way forward IMO.
Simple and elegant generally doesn't come from the LLM. It comes from me saying no to the LLM. I've discarded many branches that didn't feel like they were going the right way. Hell, I aggressively do that with my own code also. I rarely commit the first thing that works.
> where are the open source examples?
My general impression of open source is that it is, in part, a market driven by good software engineering. There's certainly below average code, but that tends to get mocked out of existence before it grows too much. Proprietary code that doesn't have a strong forcing function used to be able to hide poor engineering principles.
I think AI generated code is a regression to the mean, and the mean can be an improvement sometimes. I inherited this project. It was not originally written with AI. A lot of hard work and good engineering went into the hardware/firmware. The IoT software connecting it to our intranet, less so. Some examples that I'm fixing/fixed: ignoring HTTPS certificates, RCE by design, in-place file updating JSON files, a hand-rolled (but ineffective) fair mutex, busy waiting for a device to appear, and worst of all, no tests. None of these are hard to avoid, and even the small AI models would have come up with a better implementation.
This doesn't seem unique to my project either. I think a lot of software is just silently getting closer to the average of all open source code upon which the models were trained. I don't think I want things like SQLite to get closer to the average.
> Fully leaning into LLM doing as much of the coding and understanding as can be handed off to them seems insane to me, I don't mean this to offend though.
I think you might be reading too much into what I said. When I say "fully lean into", it's probably less than you're thinking of. I still feel that I understand what was written and can stake my reputation/career on it.
But with suitable direction, they can definitely improve codebases - especially a typical enterprise codebase, which, if you don't like LLM code, you would hate with a passion. (I can only assume you've never seen such code otherwise your perspective would be different.)
> Fully leaning into LLM doing as much of the coding and understanding as can be handed off to them seems insane to me, I don't mean this to offend though.
I essentially agree, but there's a huge spectrum before you get to that point, and lots of ways to use it effectively that doesn't create tech debt.
No, he wants a project where AI is used as a major help, but the result tend towards good code, i.e readable and well abstracted. Even if the cost is high, just an example where you can extract the best practices of using AI coding.
Now, token calculators spew out code at a pace no human can match, which completely removes the barrier of effort - which was one of the largest natural counters to shipping massive amounts of slop.
I'll be impressed by a coding model when it writes less code than a human, and spends more time refactoring than it does just adding new layers. Until then, this vibecoding is just madness.
2. This is exacerbated by the lack of loyalty people have towards their organizations because their orgs don’t value or reward loyalty. That’s because leadership doesnt care about the long term view because of item #1. Hence, everyone is only doing short 1 - 4 year stints in order to get meaningful raises
3. The exceptions in the private sector are businesses that not publicly traded.
4. Even then, very few people care about quality that no one else can see
it really isn't a flex ppl think it is when they're burning tokens churning agents that are working for "hours" doing work
we don't need to read or write code anymore, but we do need to write (as humans) the instructions for agents.
having ADRs, product specs, acceptance criteria, etc. that are properly maintained leads to agents working for just a few minutes and pumping out reliable code.
the more vague the work for agents, the more randomness and inefficiency there will be. that leads to bugs, constantly re-writing code, etc.
imo ofc, i'm not yet running a billion dollar company so maybe i'm wrong.
Whatever, I drove down to this set of huge industrial warehouses with trucks coming and going by the dozen and found the customer service office.
“That’ll be half an hour, I recommend waiting at the cafe.”
“Half an hour for what? Aren’t all the packages right here?”
“They are, but looking up the package ID in the system takes at least 30 minutes, maybe 33.”
“33!? Wait… don’t tell me, let me guess: it has been getting slowly and steadily worse over years? Predictably taking longer and longer, right?”
“Yeah, six months ago it was 27 minutes! How did you know?”
“Umm… isn’t this a bit of drag on your operations?”
“Absolutely! Everything takes forever, every shipment is delayed, … <long rant> …”
“I… bet. Why hasn’t anyone fixed it!? It’s a one line fix!”
“No budget!”
This was one of the biggest logistics companies in the country about to undergo a multi-billion-dollar merger.
Their core business software was missing database indexes even on primary key columns!
Madness.
This also allows companies like Workforce to make billions selling the most godawful software imaginable.
We generally call it “enterprise software,” and it’s usually abysmal because the people buying/funding it are VP-level executives who care about compliance/reporting/visibility and who never have to actually use the software.
This actually comes up on HN pretty regularly. Or used to; like many topics it’s taken a back seat to AI.
i will say, at least this article says "we merge 5x more and our revert rate has stayed the same." so thats at least a metric i can start to respect
Eveyone has a backlog. What happens when you clear it in a month? Do you suddenly have better ideas about what you want to build? Do you suddenly have better intuitive designs? Do you have more users or the same users using the product twice as much? In most cases, the answer is no.
AI gives you the speed to execute when you need to, but knowing what to build and how will still remain a bottleneck.
- are the users using the new feature (repeatedly)
- what sentiment is associated with it on customer calls (extracted via call transcripts, but ideally the relevant engineer joins the call)
This is another one of the infinite meaningless metrics that AI cash burners love to use without context
1) You can merge a "new change" to fix a merge, instead of reverting
2) It's unclear whether the substance of their individual PRs are the same. Never thought I'd want an LOC metric.
3) Really, I'm going to double down on the idea that merges could be fixing merges. Also happens to increase the merge metric.
What’s the point of doing 5x more?
I don't think it makes sense to A/B test "AI-native" vs other regimes of development unless you are a large, decentralized company like an F5 company or a Big Tech. How will a team of 25 (the size of the company if you read the thread) have enough output to even A/B test the difference?
Success for what? The article opened with: "Last week Will Larson (@Lethain ) asked how leaders are evaluating engineering managers for AI skills. My reply , a list of questions to think about, got a lot of bookmarks. More broadly, I've been thinking about how to build an AI-native engineering org for a while. Sharing some lessons from the last nine months of building at FurtherAI."
The opener is "how to build an AI-native engineering org" and the context is a company of roughly 22 engineers (from a reply.) Nothing here says "evidence of success"
> I don’t see how asking how this ties back to core business results is thinking about it at the wrong level.
In an company of 22 engineers, how would you make these measurements? Would you split your company into a velocity focused group and a quality focused group and make them compete? How? What would a customer motion look like? What would these groups share? This makes no sense. This is like asking a small company to A/B test teams that used a computer vs didn't use a computer.
A larger, more mature organization has the luxury of splitting business units into AI-native vs not-AI-native workflows and comparing COGS/business objectives against each other. I know of very large tech consulting services who did exactly this around the beginning of the cloud era to figure out which aspects of their business they wanted to place on clouds and which aspects they kept on-prem, and even then that was messy because part of the value of on-prem is the scale benefit you get by owning and operating your own DC. But no 22 person engineering team I saw A/B tested this out. Companies were founded either with a cloud-first philosophy or an on-prem philosophy.
If you weren’t making intentional decisions about cloud vs on prem… why? I worked with many small businesses that did.
This feels like a value-divorced outsourced engineering mindset. You have the power to understand if things are good ideas or working!
I'm curious if you've ever worked at a startup, tried to invest in a startup, or considered purchasing a startup's product to know what it's like? The whole point is you're taking a risk trying something new and different. If you're just doing what a much bigger, established company is doing, you're fighting against an incumbent who already has much lower COGS than you.
Taking a bet on being AI-native as a startup is taking a bet that use of AI will result in lower COGS than the incumbent. As the old saying goes, "Nobody got fired for buying IBM", and yet Amazon was able to crack into that space by doing something novel. If Amazon was just IBM, why not buy IBM? The ultimate test of AI-native business models will be if these companies become the Amazon of today, or whether we'll write about them the way we wrote about "fifth generation computing" in Japan.
How's that going for you?
What can you possibly be doing as a product that justifies you releasing 60 times in a working day?
It's certainly better than the old models of releasing on a quarterly cadence with the test team and all that, but it feels like the metric has become the goal when you are releasing that often.
So I guess releasing 60 times in a working day proves that you're part of a good team /s