Join the discussion
Write your take first — we'll ask for email only when you're ready to publish.
- Hacker News
- Followup announcement post:
An Entirely New Git Hosting Network
- There’s reason I wrote high info density documentation and comments rather than committed every StackOverflow page I viewed during development pre-AI.by oefrha
- I suspect we'll move away from pull requests, because in the LLM world they're the worst way of accepting a contribution.
Verbose slop is painful to review, and it's dangerous to accept unreviewed code from a stranger.
For a maintainer it's way easier to tell their own agent to reimplement the same idea. It's still slop, but done their way, under their supervision.
For popular projects agent-made pull requests become a DoS attack. I wouldn't be surprised if projects start refusing to accept unsolicited PRs and switch to "don't call us, we'll call you". You could have an agent scanning forks of your projects to find what bugs users are fixing and what features they're adding, and use it as a roadmap, without the pressure of accepting any particular commit as-is.
I'd also like to move away from a binary merged-not-merged divide. Projects may have a stable manually-reviewed core that should be protected from agents messing it up, while allowing the sloppy parts to churn however LLMs like it.
by pornel - Provocation: pull requests were always the worst way to do it.by jeffbee
- The security implications of scanning and merging external prompts at scale are going to be interesting.by cryptonym
- And it costs at least twice the amount of tokens, so a full win for LLM providers.by classified
- > For a maintainer it's way easier to tell their own agent to reimplement the same idea.
This only makes sense if you assume the original PR was just vibe-coded with minimal human effort. Maybe one day but I don't think we are there yet.
by StilesCrisis - Take a look at his keynote at WeAreDevelopers..he starts around the 17:20 mark
https://www.youtube.com/watch?v=eSoHzgrhk6Q
He does hint around removing away from pull requests!
by autocollab - I think a Q&A-based approach is could also be a suitable way to capture the reasoning behind a project. Instead of writing documentation afterward, an AI could interview the developer throughout the process and preserve the questions and answers as project context.
Matt Pocock’s “grill-me” skill is a nice example of this idea: https://github.com/mattpocock/skills/tree/main/skills/produc...
by Imanari - Superpowers' brainstorming skill is another classic example of this. This skill with SOTA models is incredibly helpful. The results become very thorough specs/plans, ADRs, etc.
https://github.com/obra/superpowers/blob/main/skills/brainst...
by CharlesW - > Version Control Will Evolve for the Agent Boom
Isn't this the idea behind Yegg's "Beads"?
by erelong - That is more along the lines of put all the agent communication into a DB that has git’s immutable history. They still use git for the code, and beads (well, DoltDB for storage/versioning) for the tasks and a bit of non-associative memory.
On the topic, I don’t find too much of the prompting to be worth referring to later, but I do always vibe code a search the sessions local web server so I can find things later. The harnesses seem to be getting better at this, but I make a ton of directories for different branches so I can’t always remember if a session was in de512.main or de1024.main
I have had luck with telling an agent to search thru old sessions to write up how to docs or sketch out a python script to automate something having done it a few times.
by lanstin - > Our hypothesis is simple: session logs are now the most important artifact in software development, and should be stored alongside the code itself in the repository. [...] Humans can more easily understand and verify what was built and why, providing a provenance layer that leads to far faster review periods.
Did they understand the coming issues (reviews), but just came up with a completely wrong hypothesis (session logs)? I mentioned it in another comment some time ago, I think the biggest issue in VCS software arises from the combination of two separate ones...
These two things in combination are also part of the reason why we deem software engineers replaceable in the current hype cycle. Adding session logs to the VCS seems like treating the symptoms instead of the disease.- A (technical): Reviews are currently not part of the VCS - B (cultural): The amount of merged source code currently grants for higher authority/ownership of a code base than the review/verification of that codeby whilenot-dev - I don't see this taking off. LLM's produce absolute novels worth of verbose text; and nobody wants to read someone else's conversation with it, and certainly nobody wants to read a multi-year old session log that's 20,000 words long. Also, this is what commit messages are supposed to solve! And the only reason anyone looks at logs are to see what's going wrong, and usually a bisect is easier for finding bad commits rather than doing a deep dive into the specifics.
In the interest of not just being a hater and suggesting an alternative though: if you're implementing a feature (whether yourself or with the agent) have the agent write a spec for the feature and commit THAT. Now you have a nicely organized thing that AI's or people can consume which captures all the intent of the session log with much less noise.
by overgard - I tend to find that such specs as committed to git best take the form of commit messages. And then a summary, in the pull request. We also did this in the before-time.
For what its worth, agents are very capable of navigating these. I highly recommend asking an ai to go do the same thing your colleague did half a year ago for this new context, or whatever.
by RugnirViking - I am anticipating a move away from git-style version control entirely.
One possible shape is something like unison-lang's CAS AST model:
https://www.unison-lang.org/docs/the-big-idea/
This model has some significant downsides for humans, but less so for automatons. It eliminates some major problems of software development like merge conflicts, dependency hell, etc.
by oftenwrong - > Our hypothesis is simple: session logs are now the most important artifact in software development, and should be stored alongside the code itself in the repository.
Pi.dev has a feature where you can export the session as a html file and look at it later. I foresee that potentially you could store this in the same Git repository and get the benefit of reviewing how a particular code change came about during a session with an agent.
I guess the next step would be having the coding agent save that session context automatically in a folder in the git repository rather than requiring a human to export it.
This startup also seems to be operating in a similar space to tangled.org - moving code repos into a decentralised hosting environment.
by paulbjensen - entire cli maintainer here: the entire cli does exactly this, with support for agent native clis but also pi or opencode. We take the raw session logs, put it in the repo with a stable link to the commit, and then you can render it in the cli or see it in on entire.io.by soph2k
- > moving code repos into a decentralised hosting environment
It's unclear to me what Entire means by decentralized. Based on their most recent blog post (https://entire.io/blog/an-entirely-new-git-hosting-network) it seems like they just mean globally distributed, but all controlled by them.
In contrast, Tangled at least offers something where you can own your own data!
by tao_oat - This is what I am doing with my pi-brains extension for pi
https://github.com/gitsense/pi-brains
I will make another update by the end of this week that contains what I call "brain checkpoints" that will make it easier for developers to debug and understand AI reasoning.
The idea is after a task has been finished, you would commit lessons, notes, and "brain checkpoints" that are designed to live with the code.
by sdesol - When your AI consumes documents that are out of date it introduce bugs and incorrect behavior into the system. Code is the only source of truth that actually matters.
The only artifacts outside of code that I don't explicitly end-date are user-story style requirements documents that I periodically revisit with the AI to make sure they're up to date.
One of the most annoying things I've seen AI do is accidentally pull in old requirements and start building off of them.
by xcskier56 - > One of the most annoying things I've seen AI do is accidentally pull in old requirements and start building off of them.
This is actually the reason for me wanting to create what I call "Brain checkpoints". After chatting with the agent and letting it do its thing for discovery, I needed an easy way to understand what it knows at any given point. What files it has read, what tool calls were made and so forth.
Checkpoints work extremely well in Pi since you can create a branch, and have the agent generate a checkpoint based on what has changed since the last checkpoint and this information will not pollute the main conversation but you benefit from the token caching.
by sdesol - I find the value of someone steering an AI session to be practically nil for nearly everything. Nobody wonders out loud how a senior developer arrives at the result he does without an AI; they care that his deliverable is high quality and meets whatever standard/requirement exists.
So I'm not sure why people going "chop, chop" and "nah make it more red and bigger" is a useful signal of much of anything.
No, the future is a complex "gate" that checks, weighs and measures everything before it gets committed --- a local (or remote) "CI" but... more granular and far more specific and turned to the needs of the project you work on.
by mickeyp - Hi! I work at Entire. We actually have another feature that we announced called Trails which indicates Confidence, Risk, Drift of code changes to give the maintainer more confidence that the code is high quality.
Each of those signals -- confidence, risk, drift are determined by a workflow file that the maintainer can create.
And trails continuously evaluate every time a change is made.
So that's exactly what we're doing..a gate that checks and weighs and measure everything before it gets committed.
The point of us capturing the agent sessions is so we can do more things with it..like adding "gates" that verify quality!
by autocollab - > Nobody wonders out loud how a senior developer arrives at the result he does without an AI; they care that his deliverable is high quality and meets whatever standard/requirement exists.
I think the issue that many may not want to think about is, how do we promote/reward/fire developers in the AI assisted programming age. As part of code reviews, I think it will be second nature to ask "how did you arrive at the code".
by sdesol - > Our hypothesis is simple: session logs are now the most important artifact in software development, and should be stored alongside the code itself in the repository.
I don’t think this scales. We recently have been doing “spec driven development” and we are committing the specs and prompts to our repo, alongside the generated code. At the beginning it seems fine: you wanna change something, you update the spec and ask the machine to regenerate the code. Easy. Over time, though, you have hundreds if not thousands if spec files in MD. It’s all English prose. There is duplication and subtle inconsistencies. It’s difficult to search for sections of a spec. Do you create a new file for this new requirement or update an existing one? What level of detail is enough here? Should I hint the machine about using the “saga” pattern or just let it know that we are dealing with non atomic transactions distributed across services? Etc. When a colleague opens a PR updating a spec, it’s hard to suggest objective changes (at least with code, you can demonstrate the presence of bugs… not so much with English prose. Sometimes I feel like a lawyer)
All in all, it seems as if maintenance of english prose is way worse than maintenance of actual code in big enough systems. You not only need to review the spec but also review the generated code. It’s painful
by sdevonoes - If only we had a way of describing exactly and in great detail to the machine what to do! Some sort of language, maybe, idk… /sby frizlab
- Exactly. The spec should go in a git comment, NOT vcs. Or, you keep the document in history for the duration of the PR and remove it post review or pre mergeby aabhay
- I’ve had good luck with this approach:
https://github.com/williamcotton/algraf/tree/main/docs
There’s also some tests in place to make sure some things from the master spec are up to date, eg, error codes.