Hacker Newsnew | past | comments | ask | show | jobs | submit | Olscore's commentslogin

Yeah man, the PR-centric lifecycle has to change.

Working on autonomous development with agents and no human code review. The future is human oversight, without humans in the loop. A PR centric cycle is like being in a factory and standing next to a conveyor belt of PRs. Humans can't possibly review properly. They have to take a few steps back and start looking at the entire machine, evaluating the system as a whole.

https://github.com/pullboard-dev/pullboard


> A PR centric cycle is like being in a factory and standing next to a conveyor belt of PRs. Humans can't possibly review properly.

Then something is either wrong with your conception of PRs or whatever process you have been submitted to. PR is asking for feedback from people that already understand the software. It's also a learning place for anyone that is not yet familiar with the part being modified. So you have the author, the reviewers, and the learners. Which is three separate sets of people.

The PR review itself shouldn't take a lot of time (10mn is already a lot), because it's either a small change which is easily understood[0] or it's a more complex one [1] that should have a design discussion thread attached. This discussion is orthogonal to the code itself. Both should have a description good enough for the reviewer to have an idea why the change is necessary before looking at the code.

So a PR is an exchange of ideas around a real artifact, the code. If no idea is being exchanged, then it's merely a gatekeeping activity.

[0] https://cgit.freebsd.org/src/commit/?id=73b1453e6d87f9af4c47...

[1] https://cgit.freebsd.org/src/commit/?id=49a3cbc47f8e721a787e...


Yeah bro, it's a broken process. Not a misunderstanding.

pull requests are not going anywhere, if you let claude take the wheel, a company will fail (or never make it), the agents are not that good, your pullboard web copy is a great example

https://claudeourlord.com


So why bother with PRs at all, might as well just skip the charade and push to master.

Engineering the system means stepping outside of the system.

Not standing on the factory floor reviewing PR widgets.


Automating fun was not on the top of my priorities but sure.


Everybody is converging on similar ideas, but the execution isn't super clean in a lot of "software factories" popping up. Coordinating through shared written state becomes obvious once you build something complex enough. Anyways, I have been building Pullboard (open source). The original concept came from needing agent coherency on a very complicated project.

https://github.com/pullboard-dev/pullboard


Building a house has three layers:

1. Vision: what we want (our intent)

2. Blueprint: the spec we wrote (our design)

3. Inspection: checking what we built against the blueprint (the proofs)

This research makes the inspection close to perfect. But an inspection only checks the blueprint, not our vision, so a house built from the wrong blueprint can still pass a perfect inspection. The other half is making sure the blueprint matches our intent and stays that way while agents build. I'm working on that, so I think this is complementary:

https://github.com/pullboard-dev/pullboard


The author is wrong, and a software factory isn't a distraction.

People are thinking about this from a quantity angle, but the key is quality, and achieving a self-maintaining project at home. I built a distributed trading system that runs multiple strategies in US options and MUST be correct. So my goal wasn't to build huge quantities of software and pump out garbage, but to ensure correct behavior and proper fixes in the codebase with agents.

Open sourced my methodology: https://github.com/pullboard-dev/pullboard


That's just a non-sequitor though - "this isn't a distraction because I built a thing" isn't actually an argument from anything but personal satisfaction.


His argument is that you first need to know what you are building before you build the factory to build it.

If you know what you're building, the software factory is a foregone conclusion.


Yes > real issues are in this layer of intent

This is why code is going to be automated, and the software engineer is a link between organizational intent and the code. This is what I’m working on.


How does this differ from what I'm doing today? Want to say any more on the topic? This is a bit vague.


Design, writing specs: Same amount of time.

Finding the holes in your specs under automation: time spent is returned 10x

Writing code: Human 15 lines per minute. LLM: 600+ lines per minute

Functional Validation: same time per iteration. Fewer bugs with LLM when properly specified => fewer iterations. Increased awareness of LLM escaping specification boundaries feeds back into increasing quality of spec writing => fewer bugs.


The difference is that instead of spending half your time understanding the business requirements and half your time writing code, you'll spend half your time understanding the business requirements, 5% of your time typing these requirements into a chatbot, and the rest of your time doing... ????


Some of the rest of the time can be spent making it look like your ratios are the same but in reality you just take the saved time and do whatever you want with it. The decision making and reviews aren’t happening any faster anyway so just take it easy and coast a bit


I guarantee there will not actually be saved time - the bullshit will increase to more than compensate, as everyone actually fixing things will be drowned out by bullshitters just pretending to fix things and creating more actual problems.


Do they matter? Yes. Should you use them? No. (Mostly)

This is going to be opinionated from an extreme "vibe code" viewpoint, but I think the future is "GAD" Governed Agentic Development. Designing constraints that agents must follow, and therefore different forms of frameworks. What the agents need is lines in a coloring book, the human is responsible for drawing those lines. So frameworks of the future should be focused on constraining an agent to develop properly, or designing what is and is not permitted.

Building Autonomously, Open Source: https://github.com/pullboard-dev/pullboard


> So frameworks of the future should be focused on constraining an agent to develop properly, or designing what is and is not permitted.

Frameworks have always done this. Make it easy to do the right thing, add friction to doing the wrong things. Swapping s/programmers/agents/ doesn't make this some brand new earth shattering idea.

If anything agents make the job of designing frameworks or leading architecture easier because they at least have the patience to read the docs even if they don't always have the working memory to follow it all. As opposed to most humans who both don't have the working memory and don't even bother to read.


That's the wrong way of thinking of it. It should be Governed OAgentic Development, a.k.a GOD


My open source approach: https://github.com/pullboard-dev/pullboard

Most days I am capable of running 15-30 agents across 5 projects; if I had the budget it would scale. Pullboard is more of a methodology, and looking at the components alone does not reveal why it works. It's not just "orchestration" it's more like a coherence, outcomes and judgement over time.


About 25-30% of the things shipped by agents need fixes.


More than that, but with the right pipeline you can end up with very solid code in the end. It’s A highly iterative process.


How does that compare to human shipping?


I'd instead say that for both it's really at 100%, and not any number in between.

Problem is that we can't define precisely what is good enough or when software is "finished": I mean, we are trying to do that with human languages, so it should not be a surprise.

Yes, LLMs are now similarly aware of the average context a human would be aware of, but for anything specific to the situation a human has better chances of resolving the ambiguity.


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: