Comment by ashu1461

Agreed, we had agents writing standard integration/unit/e2e tests but turned out to be a ton of work reviewing just that and hard to wrap one’s head around as a developer.

We ended up building our own test platform to reduce the human bottleneck in the verification loop.

Takes the form of a hermetic test environment that run all our code and infra in a way that matches production. Our tests interact with it from the ”outside”, e.g. by driving a browser, a terminal or making API calls.

We still have coding agents writing those tests but the big difference is that we record the browser and the API calls and can review and verify through a UI without having to do any manual testing. It also serves as a regression test suite with E2E coverage, which is kind of a must to avoid coding agents making assumptions and breaking things.

Not a huge fan of the term ”software factory” but working like this I actually think it’s achievable.

I just wrote a Twitter thread about how LLMs are like chainsaws [0]

In short:

- they are very powerful

- beginners feel like they are just as good as experts

- but they can cause a LOT of damage if you don't know what you are doing

- experts will get way more done and beginners may cut off a limb or drop a tree on their car

0 - https://x.com/alexpotato/status/2090872063464509912?s=20

Maybe unpopular prediction:

I think vision models will come more into play for validating things. It’s the most like consciousness, and less like - as you put it an LLM validating its own assumptions.

It’s at least an independent way of analyzing the work (as glyphs and images).

I've had an idea for an automated verification for a while, but too busy to implement it.

For every property of the system, implement a mock that simulates a system that works, and multiple variations with forseeable bugs (models are fairly good at predicting possible bugs). Then, write a unit tests that pass on the working simulation and fail on the buggy simulations.

This way model ensures reasonably well that the unit tests test what they're supposed to. Then, you use those tests as a verification to guide the model to implement the functionality.

This approach relies on the assumption that the model can design a reasonable architecture composed of independently-testable modules. In my experience, frontier models should be able to do that.

It's really funny. I would read HN headlines about PhD research in the area of https://en.wikipedia.org/wiki/Correctness_(computer_science) and it always seemed really boring

Now it is obvious to me how important this work is

We’re actually working on this problem. It’s an interesting space to be in. Initially started with static code verification, but now we’re expanding into the area of behavioral verification (does design intent match behavior) across the application lifecycle. Currently working on getting some open source stuff ready. Check us out (https://bohmian.ai - don’t mean for those to be a plug, it’s just relevant)

Some people have alternative models review each other's output.

The future might be parallel attempts and selecting the best-of-N solutions.

[flagged]