And so agent-written `md` updates are showing up in PRs. So far it seems useful (our main repo is a 350k LOC TypeScript monolith).
Admittedly, this is way less sophisticated (& less complicated) than the "graph of edges in/out of every bounded context" in the OP, but that is probably again my "little-d" DDD perference, where I find some of "DDD at scale" patterns lead to, imo, over-engineering.
owaiswiz
Something i read in the earlier paragraphs about llms being easier to work with in greenfield projects…
My experience has been the opposite. They work well on existing projects but are not so great at new ones (unless you are just vibe coding something simple).
I think it has something to do with it being able to rely on years of established structure/conventions on existing projects that makes them better IME
soganess
Agreed! I hate the start of a project with an LLM. The code it writes is always expletive, and wrangling it with rules, hooks, plans, and what have you is just a series of half measures. I'm basically in a fistfight with a cheerful drunk keyboard.
Once there's enough code, tests, and docs to appease the prefill gods and give it an understanding of what I expect in terms of code quality, style, and TDD etiquette, I can expect more consistent performance.
That said, I've never been comfortable enough with it to let it write more than a few of functions at a time without a diff/checking-in.
I've seen folks with 500K LOC branches written by an LLM and my heart just sinks...
roveo
My experience with greenfield is that when you're just starting out, you have to be really strict and careful about overall architecture, establish a framework, provide structure, separate concerns well.
If the project is not throwaway, this first set of iterations is critical, without guidance LLMs will just bolt on things and produce special-cased spaghetti, even the very-frontier models.
Once the framework is established, it's smooth sailing.
But I haven't gotten to "very large" size yet, I expect it produces another kind of coherence problems.
fcarraldo
I’ve had a good experience with a greenfield project.
The single thing that seems to have helped is that we all agreed to use OpenSpec early on, and to commit the specs alongside the code.
I have no affiliation with OpenSpec and I don’t suspect it’s doing anything unique here, but having the intent develop alongside the code in the repository seems to have ensured that agents have a more holistic view of the project.
It’s a night/day difference when I use an agent against this codebase that integrates its changes using OpenSpec and those that ignore it.
scotty79
When asked about DDD at a job interview I joked it was Debug Driven Development, when you start with empty directory and file the first bug "The app doesn't do anything. It should ..."
Non-ironically that's pretty much the way I work with AI agents now.
I.e. an `Author.ts` has an `Author.md`, `Book.ts` has an `Book.md`.
For agents, we've given them a skill to read & write the `md` files:
https://github.com/joist-orm/joist-orm/blob/main/packages/co...
And so agent-written `md` updates are showing up in PRs. So far it seems useful (our main repo is a 350k LOC TypeScript monolith).
Admittedly, this is way less sophisticated (& less complicated) than the "graph of edges in/out of every bounded context" in the OP, but that is probably again my "little-d" DDD perference, where I find some of "DDD at scale" patterns lead to, imo, over-engineering.
My experience has been the opposite. They work well on existing projects but are not so great at new ones (unless you are just vibe coding something simple).
I think it has something to do with it being able to rely on years of established structure/conventions on existing projects that makes them better IME
Once there's enough code, tests, and docs to appease the prefill gods and give it an understanding of what I expect in terms of code quality, style, and TDD etiquette, I can expect more consistent performance.
That said, I've never been comfortable enough with it to let it write more than a few of functions at a time without a diff/checking-in.
I've seen folks with 500K LOC branches written by an LLM and my heart just sinks...
If the project is not throwaway, this first set of iterations is critical, without guidance LLMs will just bolt on things and produce special-cased spaghetti, even the very-frontier models.
Once the framework is established, it's smooth sailing.
But I haven't gotten to "very large" size yet, I expect it produces another kind of coherence problems.
The single thing that seems to have helped is that we all agreed to use OpenSpec early on, and to commit the specs alongside the code.
I have no affiliation with OpenSpec and I don’t suspect it’s doing anything unique here, but having the intent develop alongside the code in the repository seems to have ensured that agents have a more holistic view of the project.
It’s a night/day difference when I use an agent against this codebase that integrates its changes using OpenSpec and those that ignore it.
Non-ironically that's pretty much the way I work with AI agents now.