One idea I am thinking through is that I might want to use a linter to restrict the AI to only use a subset of various languages which would not need as much review.
For instance, if I wrote a web front end that only allowed certain HTML tags and certain CSS properties and no Javascript, I could avoid certain classes of errors entirely.
Or for instance, in C, if you disallow dynamic memory allocation you also avoid entire classes of errors.
These are checks I think I can configure with linters and would give me more confidence that AI generated code did not have certain errors.
At least in the USA, blame (or at least responsibility for damages) will often fall on the customer. We’ve allowed Caveat Emptor to become this awful fundamental basis of the economy. We just cross our fingers and hope that The Invisible Hand of the market stops companies from putting out defective products.
Depends. Back in the day, I worked on development tools for a commericial avionics flight management computer. The headcount for embedded hardware/software verification was greater than for development.
That was never true for software development in other domains I worked in i.e. Fortune 500 enterprise tools, compiler/design tools, networking, and semiconductor.
I work at a hyperscalar and we just send it, if something breaks the model can just open a ticket and fix it automatically and write a new test. This is much cheaper than spending a bunch of money and stalling things with human CI/CD
Whatever happened to the principle that finding a bug during design is best, finding it during development is a little worse, finding it during QA is even worse, and finding it in prod is the least acceptable?
"Let's break prod and fix it later" is a terrible attitude. It didn't start with LLMs but boy LLMs seem to be making it widespread. Would it kill developers to find problems before deployment?
The principle you suggest is idealistic and has no grounding to reality. If the cost to fix something in production is close to none, and the consequences are close to none, the principle does not reflect reality.
The breaking bugs we shipped have went up about 40% year-to-year, but the engagement, user counts and revenue has grown much more than before because of the new features that got shipped. So overall its a big net win.
AI has really laid bare how little software is valued as a craft—it's been true for time immortal but some SWEs really buy into the idea. And occasionally we're able to trick leadership into believing it too with terms like "tech debt." But now that the business has for the first time literally any other option and can trade quality for speed they're starting to skip dev entirely the way they skipped QA before.
Wouldn't the cost to fix something in production be expensive, because many things won't be reported until one of your users got pissed off enough to report it (hopefully accurately) enough to fix?
In other words, you are shifting cost onto users doing your QA now.
Its much cheaper to have the users verify the systems if they have problems with it. We have not found a decrease in engagement, monthly use of the tools and revenue despite this switch.
In general it seems like the average user does not really care about these things. Some bugs like partially broken features are live for weeks with growing engagement before someone reports them.
Functionality is secondary to engagement of the user, its much, much more important to serve the right output that will keep the user on the feature than it is to have it working 100%.
I guess if his users are somehow fine with QAing constantly broken software, then he can get away with it. As a professional who cares about my work product, I wouldn’t accept the practice. But if it’s working for some companies, I guess more power to em.
I think the fact that defective products don’t make a difference speaks to how deeply unserious much of the software industry has become.
"Unserious" is a completely subjective idealistic take here.
Let's say you're are a "serious" baker, who always puts egg wash on top of his buns. You see another baker open up shop that does not do this. You say that he is unserious and does not do things with "care" while he outsells you, it's you who are unserious and will have to close down shop when you get outcompeted.
A better analogy is if the competing baker had such poor quality control that once in a while his buns tasted like chicken, once in a while they came out green, and once in a while they made customers sick. I would call that baker unserious, even if he was making more profit.
In the food prep world, we have Health Departments that come in and shut down unserious businesses like that. In software we don’t.
Everybody is trying to copy the companies who have either already-established dominant market position or such compelling products that a bunch of paper-cut bugs don't really matter as long as they aren't catastrophically fucking people over.
you dont just get to ci/cd your way to nirvana. your ci/cd are only as good as your tests. your tests are only as good as the understanding of the tests. left to AI nobody knows what the code or the tests are doing they could just be hardcoding passes for all you know.
I was talking to some friends about how CI/CD should be used in $current_year if you have fully committed to agents.
The industry is surprisingly slow to adapt and I'm writing two capabilities I'd like standardised in the industry.
I'd like standardisation of Agentic tests (I know, it sounds terrible) but these are tests that are broader and capture fuzzy intent of the system. Unit tests, e2e tests are focused and hard to maintain. An Agentic test (or a behaviour test) is where the agent understands the underlying behaviour intent and creates scenarios on the fly and executes them.
For example, I'd imagine that Claude Code goes through multiple Agentic tests where Claude itself tries to use the software using desktop control. This would capture a much broader range of bugs and its much easier to maintain because you only need the test to have a description of the intent and not all the hardcore plumbing required in e2e tests and unit tests (like mocks ughh).
I'd like a framework where I could simply have something like SCENARIOS.md and the framework runs the scenarios by spinning up the common environment required for the test. The industry is severely lacking in this kind of capability.
The next thing missing is Agentic deployment verification.
So image that you are deploying your service and you'd need to verify multiple metrics are in shape before you promote it to all servers. Traditionally this was done either by manual checks by the developer (tiresome and prone to errors) or just having alerts on a few key metrics (not extensive).
Concretely, I'd like the agent complete access to all my metrics and logs and have it make the judgement to either promote it or not promote it or notify the developer.
You'd argue this is not required, but in my experience, having this capability gives me a lot of sanity. There are greybeards who love to gatekeep their responsibilities and would argue something like "just have good unit tests!!11!!" but that's silly.
Why these are not becoming standard or even required practices is beyond me. I'm guessing that there's a cohort of developers whose mindset is risk aversion and they are not great at intuiting what an LLM is good at and what they are bad at. Unfortunately, a lot of arguments are just silly like "but hallucination", "but just have deterministic tests", "don't overcomplicate things".
This is all good stuff to verify of course, but why would you not continually add the useful agent-created tests and verifications into a deterministic suite to ensure consistency of coverage?
For instance:
>Traditionally this was done either by manual checks by the developer (tiresome and prone to errors) or just having alerts on a few key metrics (not extensive).
Ignores the places where it's always been important enough to have automated checks on many things.
> Why these are not becoming standard or even required practices is beyond me.
It sounds like you haven't actually tried to do what your proposing then.
> tries to use the software using desktop control
This is not a solved problem yet. I've tried a number of solutions and none of them were actually good enough for what you're proposing. Don't get me wrong, I'm not saying its an unsolvable problem. Only that it isn't sufficiently solved yet.
I agree. IN addition I think many businesses/industries are still not aware of the full capability of AI yet, that is why they still do things the old way. I have several friends who work as QA. When they describe the things they do daily, I tell myself quietly that AI agents can do all of them now.
I just don't understand the premise. If we're fully committed to agents, what does it mean to talk about a test being hard to maintain or requiring hardcore plumbing? "Hey Claude, can you please mock out Component X and write a test suite capturing behaviors A, B, C of component Y. Thanks!" When in the process of typing this would I go "ughh", and why would I prefer to receive a SCENARIOS.md as output rather than a test suite?
At some point the agent rewrites Component X, or X+Y, and now many or all of your tests that hit it directly are invalid and need to be rewritten. That introduces bugs, you're changing the tests and code at the same time, so you don't know if the new ones cover the same stuff as the old one.
I won't be "fully committed to agents" re: test-writing until they reach the point where they demonstrate that they're taking contract and component boundary stability into account in placing their tests. Currently I still need to intervene.
And the tests I point it at doing instead of the ones it does by default are currently catching more would-be or latent bugs than ever before, because we're changing stuff so much faster.
Agents won't make you better, quality-wise, unless you were in a lower-percentile of code-writing ability. But they'll make you a lot faster at raw change count. How good or bad that is depends on (a) the situation the product is in and the tolerance for issues/regressions, (b) how much existing judgment and best practices you can wrangle into position on top of those changes to make the path of least resistance for the agent be smoother.
There's a reason verification and code review shouldn't be done by the person who wrote the code, and those reasons don't magically go away because a code generation tool did it instead.
Of course, since AI will be doing the writing and maintaining, there's really no reason for that any more. Let the AI do it all and wait for management to realize they're paying senior salaries to people that are little more than entering prompts, a job that really only requires someone to be able to read and write English.
This LLM as compiler analogy comes up here and there and it’s not hard to poke a hole in it.
If I generate a piece of code with LLM, and verify it to be correct; can you trust the LLM output, with the same prompt, in a new session based on my verification of my code, with the same certainty that you’d trust LLVM output for the same source code in a similar environment, ran independently? If no, why?
Yea, maybe one day in the future, "the LLM prompts" will be considered the source code. But a lot has to happen first, namely the same prompt needs to deterministically create the same intermediate code. I wouldn't check in source code that compiles a different binary every time, and we should not treat prompts as source code while they produce different code.
I agree with you on this one; the compiler output remains the same if run the next day, but AI code might not. That is why you need a strong, independent reviewer who reviews the AI code and freezes it after verification, so that next time you do not have to ask the AI to regenerate the code.
One idea I am thinking through is that I might want to use a linter to restrict the AI to only use a subset of various languages which would not need as much review.
For instance, if I wrote a web front end that only allowed certain HTML tags and certain CSS properties and no Javascript, I could avoid certain classes of errors entirely.
Or for instance, in C, if you disallow dynamic memory allocation you also avoid entire classes of errors.
These are checks I think I can configure with linters and would give me more confidence that AI generated code did not have certain errors.
I wonder how robust these linters are. E.g. In C you might find some library function that allocates and abuse it to get dynamic memory.
I think with linters you can also restrict imports. So white list or black list.
There probably are problems like that but you could come up with a set of imports that are "safe" for the AI.
Perhaps the question here should be, "Who takes the blame when it all goes south?"
At least in the USA, blame (or at least responsibility for damages) will often fall on the customer. We’ve allowed Caveat Emptor to become this awful fundamental basis of the economy. We just cross our fingers and hope that The Invisible Hand of the market stops companies from putting out defective products.
Traditionally, that'd be a joint effort between a dedicated QA team, partially supported by the engineering team, that no one wants to pay for...
Depends. Back in the day, I worked on development tools for a commericial avionics flight management computer. The headcount for embedded hardware/software verification was greater than for development.
That was never true for software development in other domains I worked in i.e. Fortune 500 enterprise tools, compiler/design tools, networking, and semiconductor.
Isn't that why there's such investment into code verification agents in the cicd pipeline?
If the future is agentic, human review will be core bottleneck that needs to be streamlined.
I work at a hyperscalar and we just send it, if something breaks the model can just open a ticket and fix it automatically and write a new test. This is much cheaper than spending a bunch of money and stalling things with human CI/CD
Whatever happened to the principle that finding a bug during design is best, finding it during development is a little worse, finding it during QA is even worse, and finding it in prod is the least acceptable?
"Let's break prod and fix it later" is a terrible attitude. It didn't start with LLMs but boy LLMs seem to be making it widespread. Would it kill developers to find problems before deployment?
Those days are long gone, unfortunately. I haven't seen anyone write a real design document in years.
The principle you suggest is idealistic and has no grounding to reality. If the cost to fix something in production is close to none, and the consequences are close to none, the principle does not reflect reality.
The breaking bugs we shipped have went up about 40% year-to-year, but the engagement, user counts and revenue has grown much more than before because of the new features that got shipped. So overall its a big net win.
Precisely, technology is there to facilitate the interest of the business, and not the other way round.
AI has really laid bare how little software is valued as a craft—it's been true for time immortal but some SWEs really buy into the idea. And occasionally we're able to trick leadership into believing it too with terms like "tech debt." But now that the business has for the first time literally any other option and can trade quality for speed they're starting to skip dev entirely the way they skipped QA before.
Wouldn't the cost to fix something in production be expensive, because many things won't be reported until one of your users got pissed off enough to report it (hopefully accurately) enough to fix?
In other words, you are shifting cost onto users doing your QA now.
Its much cheaper to have the users verify the systems if they have problems with it. We have not found a decrease in engagement, monthly use of the tools and revenue despite this switch.
In general it seems like the average user does not really care about these things. Some bugs like partially broken features are live for weeks with growing engagement before someone reports them.
Functionality is secondary to engagement of the user, its much, much more important to serve the right output that will keep the user on the feature than it is to have it working 100%.
I guess if his users are somehow fine with QAing constantly broken software, then he can get away with it. As a professional who cares about my work product, I wouldn’t accept the practice. But if it’s working for some companies, I guess more power to em.
I think the fact that defective products don’t make a difference speaks to how deeply unserious much of the software industry has become.
"Unserious" is a completely subjective idealistic take here.
Let's say you're are a "serious" baker, who always puts egg wash on top of his buns. You see another baker open up shop that does not do this. You say that he is unserious and does not do things with "care" while he outsells you, it's you who are unserious and will have to close down shop when you get outcompeted.
A better analogy is if the competing baker had such poor quality control that once in a while his buns tasted like chicken, once in a while they came out green, and once in a while they made customers sick. I would call that baker unserious, even if he was making more profit.
In the food prep world, we have Health Departments that come in and shut down unserious businesses like that. In software we don’t.
Everybody is trying to copy the companies who have either already-established dominant market position or such compelling products that a bunch of paper-cut bugs don't really matter as long as they aren't catastrophically fucking people over.
Most people don't have that luxury, though.
[dead]
How does the AI know something is broken?
Things fail (website does not load, server goes down, users complain, etc).
you dont just get to ci/cd your way to nirvana. your ci/cd are only as good as your tests. your tests are only as good as the understanding of the tests. left to AI nobody knows what the code or the tests are doing they could just be hardcoding passes for all you know.
Then you can get a verification agent to validate the quality and coverage of those tests.
it's elephants all the way down....
And when your users complain because you've left yourself with a pile of broken, unmaintainable slop?
You are working on the incorrect assumption that AI generated code are automatically broken.
Often the maintenance of the code is also left to AI, human readability is a bonus.
We’ve already stopped bothering with human reviews where I’m at.
AI:
- writes the code
- reviews the code
- designs it
- productizes it
- advertises it
- consumes it
And everything to a beat by Daft Punk.
AI 'round the world
around the world,
AI 'round the world
around the world
(while (true))
I was talking to some friends about how CI/CD should be used in $current_year if you have fully committed to agents.
The industry is surprisingly slow to adapt and I'm writing two capabilities I'd like standardised in the industry.
I'd like standardisation of Agentic tests (I know, it sounds terrible) but these are tests that are broader and capture fuzzy intent of the system. Unit tests, e2e tests are focused and hard to maintain. An Agentic test (or a behaviour test) is where the agent understands the underlying behaviour intent and creates scenarios on the fly and executes them.
For example, I'd imagine that Claude Code goes through multiple Agentic tests where Claude itself tries to use the software using desktop control. This would capture a much broader range of bugs and its much easier to maintain because you only need the test to have a description of the intent and not all the hardcore plumbing required in e2e tests and unit tests (like mocks ughh).
I'd like a framework where I could simply have something like SCENARIOS.md and the framework runs the scenarios by spinning up the common environment required for the test. The industry is severely lacking in this kind of capability.
The next thing missing is Agentic deployment verification.
So image that you are deploying your service and you'd need to verify multiple metrics are in shape before you promote it to all servers. Traditionally this was done either by manual checks by the developer (tiresome and prone to errors) or just having alerts on a few key metrics (not extensive).
Concretely, I'd like the agent complete access to all my metrics and logs and have it make the judgement to either promote it or not promote it or notify the developer.
You'd argue this is not required, but in my experience, having this capability gives me a lot of sanity. There are greybeards who love to gatekeep their responsibilities and would argue something like "just have good unit tests!!11!!" but that's silly.
Why these are not becoming standard or even required practices is beyond me. I'm guessing that there's a cohort of developers whose mindset is risk aversion and they are not great at intuiting what an LLM is good at and what they are bad at. Unfortunately, a lot of arguments are just silly like "but hallucination", "but just have deterministic tests", "don't overcomplicate things".
This is all good stuff to verify of course, but why would you not continually add the useful agent-created tests and verifications into a deterministic suite to ensure consistency of coverage?
For instance:
>Traditionally this was done either by manual checks by the developer (tiresome and prone to errors) or just having alerts on a few key metrics (not extensive).
Ignores the places where it's always been important enough to have automated checks on many things.
> Why these are not becoming standard or even required practices is beyond me.
It sounds like you haven't actually tried to do what your proposing then.
> tries to use the software using desktop control
This is not a solved problem yet. I've tried a number of solutions and none of them were actually good enough for what you're proposing. Don't get me wrong, I'm not saying its an unsolvable problem. Only that it isn't sufficiently solved yet.
I agree. IN addition I think many businesses/industries are still not aware of the full capability of AI yet, that is why they still do things the old way. I have several friends who work as QA. When they describe the things they do daily, I tell myself quietly that AI agents can do all of them now.
I just don't understand the premise. If we're fully committed to agents, what does it mean to talk about a test being hard to maintain or requiring hardcore plumbing? "Hey Claude, can you please mock out Component X and write a test suite capturing behaviors A, B, C of component Y. Thanks!" When in the process of typing this would I go "ughh", and why would I prefer to receive a SCENARIOS.md as output rather than a test suite?
How stable is the boundary of Component X?
At some point the agent rewrites Component X, or X+Y, and now many or all of your tests that hit it directly are invalid and need to be rewritten. That introduces bugs, you're changing the tests and code at the same time, so you don't know if the new ones cover the same stuff as the old one.
I won't be "fully committed to agents" re: test-writing until they reach the point where they demonstrate that they're taking contract and component boundary stability into account in placing their tests. Currently I still need to intervene.
And the tests I point it at doing instead of the ones it does by default are currently catching more would-be or latent bugs than ever before, because we're changing stuff so much faster.
Agents won't make you better, quality-wise, unless you were in a lower-percentile of code-writing ability. But they'll make you a lot faster at raw change count. How good or bad that is depends on (a) the situation the product is in and the tolerance for issues/regressions, (b) how much existing judgment and best practices you can wrangle into position on top of those changes to make the path of least resistance for the agent be smoother.
That really to the point of tests. You WANT to know when they are invalidated. You want them to be fairly easy to read.
Good tests are so easy to write with these models, and so easy to fix as the code changes it they are too closely tied to the implementation.
[dead]
[flagged]
[flagged]
[flagged]
If you build guardrails on what is generated, verification is done at the same time as generation.
A lot of the risk is insider risk. A hacked credential, an annoyed engineer going to a competitor, etc.
Think embezzlement. Think someone with a political agenda who changes the homepage on the way out the door.
Having a single point of control is asking for trouble.
There's a reason verification and code review shouldn't be done by the person who wrote the code, and those reasons don't magically go away because a code generation tool did it instead.
Of course, since AI will be doing the writing and maintaining, there's really no reason for that any more. Let the AI do it all and wait for management to realize they're paying senior salaries to people that are little more than entering prompts, a job that really only requires someone to be able to read and write English.
It’s amazing how much developers want to automate themselves out of a career.
This is mathematically challenging as your system gets more complicated.
If you give up on trying to reduce the number of permutations you need to test, you're gonna also (even if not intentionally) give up on testing them.
We knew this, of course. But everything old is new again.
what are the guardrails?
if there are many of them (e.g. unit tests), who generates those guardrails and who verifies their correctness?
if they are a few, then how can they cover vast product capability surface?
it's bull-crap
Guard-rails are totally ineffective
What "guardrails" specifically ensure that? I assume you have a more interesting idea than simply suggesting more tests.
“Make no mistake.”
[dead]
The same people that verify what a compiler spits out?
This LLM as compiler analogy comes up here and there and it’s not hard to poke a hole in it.
If I generate a piece of code with LLM, and verify it to be correct; can you trust the LLM output, with the same prompt, in a new session based on my verification of my code, with the same certainty that you’d trust LLVM output for the same source code in a similar environment, ran independently? If no, why?
Yea, maybe one day in the future, "the LLM prompts" will be considered the source code. But a lot has to happen first, namely the same prompt needs to deterministically create the same intermediate code. I wouldn't check in source code that compiles a different binary every time, and we should not treat prompts as source code while they produce different code.
I agree with you on this one; the compiler output remains the same if run the next day, but AI code might not. That is why you need a strong, independent reviewer who reviews the AI code and freezes it after verification, so that next time you do not have to ask the AI to regenerate the code.
That would be compiler writers, which seems unlikely.
Anyone can look at compiler output and verify its correctness.
The question wasn’t who can, but who does.
That's a big assumption. We don't even have formal specifications for many popular high level languages so there's nothing to verify against.
kek