11 ms·

Verified Spec-Driven Development (VSDD)

211 points by todsacerdoti 8mo ago

politician 8mo ago
This is a decent approach. My concern with TDD is that writing tests necessarily implies designing an API upon which those tests operate. Here, the agent is instructed to "not write code, write tests", and yet, in doing so it defines an API. This will cause the AI to hallucinate the API. Layering in yet more tests on top of this will cause that API to deform in strange ways that pass tests but that the adversary will not be able to cope with because it runs too late in the VSDD process. I've seen this exact process play out in my own work. The AI generates code and tests that pass with high code coverage and honors invariants set by spec. I look at the code and find a rats nest / ball of mud that will cost 10x more tokens to enhance should I ever need to add a feature. So, I think you're on to something, but I think the process might be discounting extensibility and resilience under change.
- NeutralForest 8mo ago
  > My concern with TDD is that writing tests necessarily implies designing an API upon which those tests operate It really forces you to do outside-in testing; I usually describe the kind of API I want when chatting with the agents. For example, the CLI options, the routes that might be useful for an API, etc. > I look at the code and find a rats nest / ball of mud that will cost 10x more tokens to enhance should I ever need to add a feature. Agreed, I don't know if there are good forcing functions to avoid complexity. The providers have a huge incentive to have you waste your tokens (for example when it re-outputs the complete file when you ask for a tiny change).
  - bonesss 8mo ago
    “Test Driven Design” is another way to frame it.
  - 0x457 8mo ago
    In "proper" TDD you you supposed go: - write a test for method that does not exist, it just calls the method and nothing else - write method that does nothing - add/extend test that uses that method <-- this very loop starts - modify method until tests passes - go back to loop start until you're done I always hated it. When I work with LLM i first massage interface that tests, then tests, then implementation until all these tests pass. > for example when it re-outputs the complete file when you ask for a tiny change). well with sonnet 3.5 and 4.5 (can't say about 4.6) it often will get stuck in a loop trying to update just the required parts and iether waste tons of tokens doing these updates or waste tons of tokens to a point where restring file from git is required. Tokens get wasted regardless.
    - skydhash 8mo ago
      I like tests, but I don't bother with TDD because it's so ceremonial. I design the API, or at least sketch it out (using a whiteboard or drafting some notes, and doing research). Then I iterate and refine. I only bother with tests once I can commit or when it's no longer viable to tests manually (edit-compile-run cycle). And a lot of time I follow the table pattern. https://www.oreilly.com/library/view/simplicity/9798888651704/f_0049.xhtml https://www.oreilly.com/library/view/simplicity/979888865170...
- DaylitMagic 8mo ago
  I see what you're saying. Modularity and interfaces are really important between the different aspects of what's being developed. And it is worth putting time into the question "if another will use this, what would they potentially use it for, and why?". It doesn't mean that it needs to be built now - but considering that and ensuring that the planned code executes against that is a good strategy.
sjbr 8mo ago
Nice. It can work with something like https://github.com/github/spec-kit https://github.com/github/spec-kit ?
- beders 8mo ago
  My employer is trying to convince us to embrace spec-kit. But we are a Clojure shop: we iterate fast and produce results. We don't sit around and write specs and then hope working code plops out.
  - adastra22 8mo ago
    With AI tools, spec-driven development is the lowest latency option.
  - samusiam 8mo ago
    > We don't sit around and write specs and then hope working code plops out. So what do you do then? Sit around hand-holding an AI agent while it implements code line-by-line? I'm being facetious, but my point is that if you're not doing some form of spec-driven development (that is, writing a plan and then letting an AI agent implement it mostly autonomously), then you might be operating at a slower pace than you think you are.
_pdp_ 8mo ago
Everything in this post stems from the assumption that you already know what you're doing, which is probably true for things you've built before. But I hope we can agree that you can't spec out something you have no clue how to build, let alone write the tests before you've even explored the boundaries of the problem space. That's completely unreasonable. My second point is that this approach is fundamentally wrong for AI-first development. If the cost of writing code is approaching zero, there's no point investing resources to perfect a system in one shot. What matters more is how fast you can explore the edges. You can now spin up five agents to implement five different versions of the thing you're building and simply pick the best one. In our shop, we have hundreds of agents working on various problems at any given time. Most of the code gets discarded. What we accept to merge are the good parts.
- DaylitMagic 8mo ago
  If you don't mind the question with regard to your second point, couldn't what you've done in your shop be also used here? There's no reason why 'try to develop it five different ways and pick the best parts out of each' is incompatible with the 'VSDD' concept; seems like it could be included?
- politician 8mo ago
  "Most of the code gets discarded." If you don't mind sharing, what's your signal-to-token ratio?
  - kvdveer 8mo ago
    How do you propose we measure signal? Lines of code is renowned for being a very bad measure of anything, and I really can't come up with anything better.
    - politician 8mo ago
      The OP said that they kept what they liked and discarded the rest. I think that's a reasonable definition for signal; so, the signal-to-token ratio would be a simple ratio of (tokens committed)/(tokens purchased). You could argue that any tokens spent exploring options or refining things could be signal and I would agree, but that's harder to measure after the fact. We could give them a flat 10x multiplier to capture this part if you want.
DaylitMagic 8mo ago
Some random (hopefully additive and helpful) thoughts: Many companies have older code bases / databases that can be somewhat well defined (and somewhat not). If things have been slowly iterating over 35 years, there's a lot of undocumented edge behavior that may occur; it may be beneficial to have a step before Edge Case Catalog where there's some kind of prompting to catalogue how the inputs and outputs work, and then find the different inputs and outputs - and then confirm that with Input A and Output A that it works as expected. (Legacy systems often have weird orchestration that nobody remembers.) (Sub-note: This is somewhat part of the provable properties catalog; while this step could be placed there, it would require a re-run of edge case catalog build potentially, which isn't a bad thing.) A small note that I personally think is a good idea is better code commenting than has been outlined here - the spec itself should be woven into the code with potentially slightly over-commenting for each aspect, code spec gets lost. The code itself should serve as context, especially in the TDD stage. I think it's implicit but may be worth overtly stating that for the Code Quality check in Phase 3 that it also checks on a zero-trust basis, and doesn't include things like hardcoded keys. I'm not sure what Chainlink is (sorry!) but I like the ideas outlined around the decomposition - but it misses stringing everything together end-to-end in the way outlined here (it asks to create each part, but never actually weaves the whole together). Something not covered - is sequencing work and decomposition of work. A spec can create multiple dependencies within itself, requiring things to be worked on in a specific order.
galoisscobi 8mo ago
I think this word salad doesn’t have enough buzzwords. Throw in a few more acronyms too.
desireco42 8mo ago
Claude or something different... there is life beyond Claude I assure you and it is quite good and colourful.
mitchbob 8mo ago
Upvoted for the Sarcasmotron.
esafak 8mo ago
This is AI slop not worth my time. What would be interesting is if the author shared her practical experience in implementing it. Let's see some of those specs. What tricky bugs did it catch? The author's latest repo hasn't even been passing CI, so what does that say? https://github.com/dollspace-gay/Tesseract-Vault/commits/main/ https://github.com/dollspace-gay/Tesseract-Vault/commits/mai...
- relativeadv 8mo ago
  yes, all of the typical signs and symptoms appear to be there. Lists upon sublists of verbose overengineered plausibly thoughtful writing. If you can't be bothered to write it, why should i be bothered to read it?
- dollspace 8mo ago
  The runners are failing because it moved them from github hosted to self hosted and its requiring fixes, but you would know that if you actually paid attention to the commits and werent just looking for cheap dunks. Have a good one.
  - esafak 8mo ago
    I looked at the past few pages of your repo's history and half the time it is broken. Is this continued failure despite using a verified spec, or did you not use one? If not which repo should we look at instead? I am sorry but I see nothing from you to engage here.
    - dollspace 8mo ago
      [dead]
vielite1310 8mo ago
I would like to be enlightened myself if RPI,BMAD or any spec-driven approaches actually worked for any mid/large scale projects, without wasting millions of tokens of course :)
- rsrsrs86 8mo ago
  Real spec driven uses no tokens
SirensOfTitan 8mo ago
LLM-assisted development feels a lot like trend-driven development. When dealing with technique and heterogenous prompts and goals, it’s easy to gain somewhat of a gambler’s fallacy with respect to a particular technique. Spec-driven development feels pretty questionable to me. I’m sure it works fine for feature work that is predictable or has been done before, but then I wonder why you’d waste your time with it. Prior to LLMs, the whole vibe was to iterate rapidly toward a working thing so you can see what works and what doesn’t. Why would we abandon that strategy as an industry when the cost of writing code is ostensibly getting cheaper? If I’m using LLMs at all, I’m using them to do a breadth search of prior art or ideas, then I’m doing what I might call a prototype onion: successive clean room attempts at a novel problem, accumulating what I learn at each attempt in each successive prompt. I usually then take the prototype and write the final version myself so I’m properly internalizing the idea. Ultimately a lot of this prompt work feels like procrastination. It is not about understanding where these tools is useful and where they are not but trying to have them consume every aspect of the work.
- getnormality 8mo ago
  Or maybe people who like talking much more than they like code are now very excited about the possibility that talking has eaten software development. This is exactly backwards. For many tasks, formal languages are better, more real, more beautiful than English. No matter how many millions of tokens you have, you will never talk the formulas of Fermat, Euler, and Gauss into irrelevance. And the same is true of good code. Of course, a lot of code is ugly and utilitarian too, and maybe talking will make it less painful to write that stuff.
  - skydhash 8mo ago
    > a lot of code is ugly and utilitarian too, And as everyone who can abstract well knows: Ugly code that have staying power have a reason to be ugly. And the best will be annotated with HACK and NOTE comments. Anything else can be refactored and abstracted to a much better form. But that requires a sense of craftsmanship (to know better) and a time allowance for such activity.
  - 8mo ago
pron 8mo ago
If you come up with a strategy that seems to "solve programming", then you know for certain there must be a flaw in it, and you need to identify where it is that corners must be cut and how. Computer science is an introspective discipline because it studies the essential difficulty of problems regardless of the process taken to solve them, and programming itself (i.e. the problem of producing a correct, or correct-enough program) is such a problem that can be, and has been studied. The question of learning whether a program X satisfies some correctness property P is known as the model-checking problem, and we know that answering it with certainty is intractable. For example, some properties that are true for some program would take no less than 10 minutes to verify (regardless of how that verification is done), others will take no less than 10 hours, others no less than 10 months, others no less than 10 years and so on, and we don’t know ahead of time whether the proprty is true, and if it is, where on this spectrum it falls. So suppose you decide some property must be proven with full certainty, the question becomes, how long do you wait before giving up waiting for the validation and what do you do when you give up? If you then decide that you’re okay with less than 100% confidence, what approach do you take and how much confidence do you actually have? The problem with that is that the answer to that question often requires a deep understanding of the implementation. I.e. if you have two programs, X and Y, that compute the same function, one less-than-perfect approach would give you 99% confidence with one of them, but only 10% confidence with another.
- twoodfin 8mo ago
  More, “If your LLM comes up with a strategy to ‘solve programming’ …”
deleted 8mo ago
[deleted]
Robdel12 8mo ago
I’ve gotten the absolute best results from LLMs just acting like the software engineer I’ve aspired to be the past 15 years. Normal dev things. Scope the ticket properly, break it down. Test well. Write the correct docs. LLM specific things are going to be gone next week
- twodave 8mo ago
  I feel this very recently. I just pretend the agent is a junior dev and tell them to do things I don’t have time for. Reviewing the changes at my convenience is a lot like checking in on a junior dev, too. On the other hand I do feel like I get better results with the same teeing up that a junior dev requires, so I try to remove as many unknowns/dependencies as possible (or else explicitly tell it to leave some things as stubs) before sending him off to do something
  - actionfromafar 8mo ago
    Junior devs who know a lot more maths than I do...
beders 8mo ago
> Define the contract before writing a single line of implementation. Specs are the source of truth. There is only one source of truth and that is the source code. To define and change contracts written in an ambiguous language and then hope the right code will magically appear, is completely delusional. Iteration is the only game in town that is fast and produces results.
choeger 8mo ago
If I am not mistaken, the verification is problematic here. It's run too late. A piece of code that satisfies a single test will most likely not be probable to adhere to the spec. Worse, the whole spec can only be correctly implemented in total. You cannot work iteratively by satisfying one constraint after the other. The same holds for the test cases. That means that satisfying the last test or fulfilling the last constraint will take much more work than the first. The number of tests passed is not a good metric for completion of the implementation.
melvinroest 8mo ago
I've been doing something less formal. I stumbled upon Riaan Zoetmulder's free course on deep learning and medical image analysis [1] and found his article on spec-driven development [2]. He adapts the V-Model by specifying three things upfront: requirements, system design and architecture. The rest gets generated. He mentioned a study where they show that LLM assistance slowed down experienced open source devs on large codebases. The model doesn't know the implicit context. And to me that's the thing! An LLM should have an index of some sort. So I vibe coded my own static analysis program where I just track my own function calls. It outputs a call graph of all my self-defined functions and shows the name (and Python type hints) of what it is calling (excluding standard library function, also only self-defined stuff). Running that program and sending the diff from time to time seems to have helped a lot already. [1] https://www.riaanzoetmulder.com/courses/deep-learning-medical-imaging/ https://www.riaanzoetmulder.com/courses/deep-learning-medica... [2] https://www.riaanzoetmulder.com/articles/ai-assisted-programming-project-setup/ https://www.riaanzoetmulder.com/articles/ai-assisted-program...
- xcubic 8mo ago
  I am not following, can you give a concrete example of your workflow?
  - melvinroest 8mo ago
    In my agent file I explain that I have a static analyzer which generates a callgraph. On starting the agent runs ~/.agent/tools/__callgraph__/generate_callgraph.py It then gets to see callgraph.current.md and upon subsequent sessions callgraph.diff.md. Here is an example of some output that I currently have in callgraph.current.md ## src/components/Header.tsx - **export Header({ ... }: Props)** (start 9, end 54) → `useAuth` ## src/components/HelpTooltip.tsx - **export HelpTooltip({ ... }: Props)** (start 15, end 42) → (none) ## src/components/ResultsTable.tsx - **getHeaderLabel(col: { id: string; columnDef: { header?: unknown } }): string** (start 45, end 51) → (none) - **getCellValue(colId: string, original: KeywordResult): string** (start 53, end 74) → (none) - **export ResultsTable({ ... }: Props)** (start 76, end 406) → `getCellValue` ## src/components/SettingsDrawer.tsx - **export SettingsDrawer({ ... }: Props)** (start 158, end 336) → (none) For example: ResultsTable calls getCellValue. In these cases it's just one function but you also have stuff like **export Dashboard()** (start 36, end 635) → `getTopKeywords`, `normalizeText`, `searchKeywords`, `searchKeywordsMulti`, `searchSemantic`, `searchSemanticMulti` For the Python version it also gives the parameters and types along with it. I think the next thing I'd need to do is give self-defined type definitions. Doing things this way allows an LLM to not read all that much but to be able to reason relatively well over what the code does. The caveat is that you abstracted your code well. If you didn't, the LLM doesn't know your implementation. I probably should also add return types.
alpaylan 8mo ago
You cannot escape from the human verifying the properties you want verified mechanically. This only gives you leverage in specific scenarios where specification is much simpler than the implementation.
jatins 8mo ago
The gist is 100% AI written https://www.pangram.com/history/9d89ebba-cdba-40e1-b569-9ae1c2d44c13?ucc=PQCmbwNZf1k https://www.pangram.com/history/9d89ebba-cdba-40e1-b569-9ae1...
WestN 8mo ago
Short take: replace TDD with BDD, and might add DDD as a spice. Otherwise this is a fairly good article. Why not TDD? Since a lot of developers use LLMs to create tests today, plus a lot of the training data contains information on how to do this. Making it something that it either can figure out to do by itself or that it will cheat. Both equally bad. A somewhat controversial take is that you should simply avoid writing tests which the LLM can produce by itself, similar to how we in the last week removed the agents.md file.
- chrisweekly 8mo ago
  could you say more about removing agents.md?
  - supermdguy 8mo ago
    Probably referencing this: https://news.ycombinator.com/item?id=47034087 https://news.ycombinator.com/item?id=47034087
    - chrisweekly 8mo ago
      thanks btw, if you're right, that post's top comment seems to make a strong case for keeping agents.md
- esperent 8mo ago
  Modern testing frameworks already use BDD (behavior driven development , which simply means writing tests in natural language. BDD is a superset of TDD: import { describe, it, expect } from 'vitest'; describe('User Authentication', () => { it('should allow login with valid credentials', () => { const result = login('user@example.com', 'password123'); expect(result.isAuthenticated).toBe(true); }); This is BDD and every testing framework I've used in my entire career and 95% of the tests I've written look something like that.
daveac 8mo ago
In a perfect world I can see this happening. But with AI increasing or output I think the real bottleneck is work sponsors, business logic and requirements discovery/translating/sign off. I am seeing more teams and features being rolled faster than before but then discovering that the sponsors (those requesting features and change) either don’t invest the time up front or with timely feedback loops and work stalls or has to be redone as business does not see the results until it’s either live or about to go live. This has always been the case but I think AI tooling has moved the bottleneck
rsrsrs86 8mo ago
That’s how I do it, minus the marketing.
teiferer 8mo ago
I expected formal verification to be part of this. That could not be fooled and is rock-solid, unless you cheat in your specification. Swap your AI "verifier" out for that and I'm on board.
mpalmer 8mo ago
Looks moderately interesting, but I refuse to upvote vibe-written submissions. Of course documents like this have their uses, but: - They cannot easily be attributed to a human author, and therefore debates and discussions on the substance of the ideas tend not to get too far - They (tend to) take well-established concepts, glue them together, and describe the result in reverential tones, regardless of the relative triviality of the solution. Hard to rule that out here tbh. I am not saying any of that is what's happening here. What I am saying is that I'm not going to waste my time reading something I can't easily vet for quality. Author (not OP) has written plenty of its* own words on Bluesky over the last few weeks. If it's written anything longhand about this stuff I'd be interested to read it. But for now "anti-slop bias" designed into the system has not reached the prose. *respecting pronouns
FrankRay78 8mo ago
No much different from what I did manually when employer outsourced development to India.
Animats 8mo ago
Is the posting a description of a real system, or just imagination? Is there a link to something that makes this real?
- zozbot234 8mo ago
  Imagination? More like hallucination - the AI-generated kind.
- rsrsrs86 8mo ago
  It is very fluffy, but the idea of using formal methods works. It just never settles down… the workflow keeps improving and changing. You don’t need stable tools
jFriedensreich 8mo ago
Its an interesting direction if you see it under the umbrella of diminishing costs: You build a product once with vibe coding and a design/ product hat. Once you know what works you rebuild it 100% in a framework like this. You do this every time from scratch when the tech debt or the mismatch between architecture and needs are too big.
- rsrsrs86 8mo ago
  I do exactly this. The database schema won’t change as often.
- gck1 8mo ago
  You could also use the same framework always - that's what I'm doing anyway. But you gotta remember that no matter how well you spec it, first iteration of the specs is going to suck anyway. But you vibe-code it anyway and see what happens. You'll start noticing obvious issues that you can track back to something in spec. Then you throw away the entire thing (the entire project!) and start from scratch. Repeat until you have something you like. Incremental specing doesn't work though. You need a clean room approach with only important learnings from previous iterations. Otherwise agent will never pick a hard but correct path.
johnnyAghands 8mo ago
Does anyone know what Chainlink is?
- zellster 8mo ago
  I am guessing it is an issue tracker created by the same author. Github link: https://github.com/dollspace-gay/chainlink https://github.com/dollspace-gay/chainlink
dhorthy 8mo ago
software engineering is still software engineering. just because you don't type out the characters doesn't mean you're not designing systems and thinking critically and leveraging your experience. also: do we think this is written by ai? do we care anymore?
- tkel 8mo ago
  Yes it's very obviously written by AI and made me immediately close the tab. Not gonna read a self-promotional piece written by an LLM that someone probably only gave it one sentence prompt: "merge these ideas".
- frez131 8mo ago
  I personally care deeply when content intended as communication is AI generated (much more so than if code is generated). On the surface level, I find it a bit disrespectful when I'm communicating with someone who's just using an LLM to generate their responses. Imagine if you are talking to someone in-person, and they pull out a phone, generate a response then read it back out to you? On a deeper level, if someone's generated a bunch of text and clearly hasn't devoted the time into generating/editing it that they're expecting me to invest while reading it, I'm just not going to read it.
syndacks 8mo ago
Does anyone have any solid patterns they can share around the “scenarios”/holdouts concept from the Dark Factory, where you create external system(s) to verify your main one?
- xomiachuna 8mo ago
  So bdd essentially?
ozozozd 8mo ago
We’re launching markdown now, aren’t we?
mobrienv 8mo ago
Doing something similar with https://github.com/mikeyobrien/ralph-orchestrator https://github.com/mikeyobrien/ralph-orchestrator It's much more than a simple Ralph loop.
vivzkestrel 8mo ago
- you most certainly also wanna read this one https://boristane.com/blog/the-software-development-lifecycle-is-dead/ https://boristane.com/blog/the-software-development-lifecycl...
dworks 8mo ago
I've implemented a version of this in rlm-workflow: https://skills.sh/doubleuuser/rlm-workflow/rlm-workflow https://skills.sh/doubleuuser/rlm-workflow/rlm-workflow
cadamsdotcom 8mo ago
Some of the ideas here are codified in a simpler way in my TDD framework, CodeLeash (https://codeleash.dev https://codeleash.dev). The key difference is CodeLeash puts guardrails outside the model, as Claude Code hooks. It can’t forget or skip steps, it gets forced through a process. There are bypasses but they raise alarms that the model is also forced to review. Putting guardrails outside the model forces deterministic process following. With a sufficiently capable process (TDD is a powerful way to build software) you can really scale up coding agent usage.
- virgilp 8mo ago
  Cool but it is not a framework for working with AI, it is an _opinionated_ framework for building full-stack apps right? As in, I can't use any of it if I'm building, say, a Spark data processing pipeline. Or a ML framework. Or automation software that runs on custom processors. The idea of "guardrails outside the model" is definitely appealing but I wonder if you can make it generalize well.
  - cadamsdotcom 8mo ago
    You’re right of course, the framework is pretty rigidly tied to full stack. But the underlying idea I think has power - find a process you can codify enforcement of rather than telling models how they should do things. Spec driven development probably means creating tooling to track how code maps to specs, for example.. and then working out how to manage that as data. Then you can query the data to confirm all mappings between code and specs. That gets you out of the business of nicely and repeatedly asking very expensive and undependable models such queries :)
- tinodb 8mo ago
  Nice, I had the same idea for a enforced TDD state machine! I wouldn’t tie it to all the other stuff though, but I might try it out.
  - cadamsdotcom 8mo ago
    The TDD guard is the most isolated part of the whole thing, you could just take the files involved and ignore the rest. Maybe 6-7 files all referenced from the .claude/settings.json hook config. Would be glad to see how you go!
hamdouni 8mo ago
So we are cycling back to kind of Waterfall Development ? No more agility ? The trend is dead by AI ?
- virgilp 8mo ago
  "Waterfall" got a bad rep because it meant "we stay months in the requirements gathering, then months design phase, then months in development, then months in validation". If you compress "months" to days/hours, what you obtain is something that nobody from the 90s would recognize as "waterfall"; it is not the end of agility, far from it.
entrustai 8mo ago
[dead]
euroderf 8mo ago
I don't see any discussion here (in these comments) of requirements management. Is the very idea of RM too organized for people eager to spin up a bunch of LLMs and watch the code generation fly ? Or has RM been tried with LLMs and found lacking ?

211 points by todsacerdoti 8mo ago

This is a decent approach. My concern with TDD is that writing tests necessarily implies designing an API upon which those tests operate. Here, the agent is instructed to "not write code, write tests", and yet, in doing so it defines an API. This will cause the AI to hallucinate the API. Layering in yet more tests on top of this will cause that API to deform in strange ways that pass tests but that the adversary will not be able to cope with because it runs too late in the VSDD process. I've seen this exact process play out in my own work. The AI generates code and tests that pass with high code coverage and honors invariants set by spec. I look at the code and find a rats nest / ball of mud that will cost 10x more tokens to enhance should I ever need to add a feature. So, I think you're on to something, but I think the process might be discounting extensibility and resilience under change.

NeutralForest 8mo ago
> My concern with TDD is that writing tests necessarily implies designing an API upon which those tests operate It really forces you to do outside-in testing; I usually describe the kind of API I want when chatting with the agents. For example, the CLI options, the routes that might be useful for an API, etc. > I look at the code and find a rats nest / ball of mud that will cost 10x more tokens to enhance should I ever need to add a feature. Agreed, I don't know if there are good forcing functions to avoid complexity. The providers have a huge incentive to have you waste your tokens (for example when it re-outputs the complete file when you ask for a tiny change).
- bonesss 8mo ago
  “Test Driven Design” is another way to frame it.
- 0x457 8mo ago
  In "proper" TDD you you supposed go: - write a test for method that does not exist, it just calls the method and nothing else - write method that does nothing - add/extend test that uses that method <-- this very loop starts - modify method until tests passes - go back to loop start until you're done I always hated it. When I work with LLM i first massage interface that tests, then tests, then implementation until all these tests pass. > for example when it re-outputs the complete file when you ask for a tiny change). well with sonnet 3.5 and 4.5 (can't say about 4.6) it often will get stuck in a loop trying to update just the required parts and iether waste tons of tokens doing these updates or waste tons of tokens to a point where restring file from git is required. Tokens get wasted regardless.
  - skydhash 8mo ago
    I like tests, but I don't bother with TDD because it's so ceremonial. I design the API, or at least sketch it out (using a whiteboard or drafting some notes, and doing research). Then I iterate and refine. I only bother with tests once I can commit or when it's no longer viable to tests manually (edit-compile-run cycle). And a lot of time I follow the table pattern. https://www.oreilly.com/library/view/simplicity/9798888651704/f_0049.xhtml https://www.oreilly.com/library/view/simplicity/979888865170...
DaylitMagic 8mo ago
I see what you're saying. Modularity and interfaces are really important between the different aspects of what's being developed. And it is worth putting time into the question "if another will use this, what would they potentially use it for, and why?". It doesn't mean that it needs to be built now - but considering that and ensuring that the planned code executes against that is a good strategy.

sjbr 8mo ago

Nice. It can work with something like https://github.com/github/spec-kit https://github.com/github/spec-kit ?

beders 8mo ago
My employer is trying to convince us to embrace spec-kit. But we are a Clojure shop: we iterate fast and produce results. We don't sit around and write specs and then hope working code plops out.
- adastra22 8mo ago
  With AI tools, spec-driven development is the lowest latency option.
- samusiam 8mo ago
  > We don't sit around and write specs and then hope working code plops out. So what do you do then? Sit around hand-holding an AI agent while it implements code line-by-line? I'm being facetious, but my point is that if you're not doing some form of spec-driven development (that is, writing a plan and then letting an AI agent implement it mostly autonomously), then you might be operating at a slower pace than you think you are.

_pdp_ 8mo ago

Everything in this post stems from the assumption that you already know what you're doing, which is probably true for things you've built before. But I hope we can agree that you can't spec out something you have no clue how to build, let alone write the tests before you've even explored the boundaries of the problem space. That's completely unreasonable. My second point is that this approach is fundamentally wrong for AI-first development. If the cost of writing code is approaching zero, there's no point investing resources to perfect a system in one shot. What matters more is how fast you can explore the edges. You can now spin up five agents to implement five different versions of the thing you're building and simply pick the best one. In our shop, we have hundreds of agents working on various problems at any given time. Most of the code gets discarded. What we accept to merge are the good parts.

DaylitMagic 8mo ago
If you don't mind the question with regard to your second point, couldn't what you've done in your shop be also used here? There's no reason why 'try to develop it five different ways and pick the best parts out of each' is incompatible with the 'VSDD' concept; seems like it could be included?
politician 8mo ago
"Most of the code gets discarded." If you don't mind sharing, what's your signal-to-token ratio?
- kvdveer 8mo ago
  How do you propose we measure signal? Lines of code is renowned for being a very bad measure of anything, and I really can't come up with anything better.
  - politician 8mo ago
    The OP said that they kept what they liked and discarded the rest. I think that's a reasonable definition for signal; so, the signal-to-token ratio would be a simple ratio of (tokens committed)/(tokens purchased). You could argue that any tokens spent exploring options or refining things could be signal and I would agree, but that's harder to measure after the fact. We could give them a flat 10x multiplier to capture this part if you want.

DaylitMagic 8mo ago

Some random (hopefully additive and helpful) thoughts: Many companies have older code bases / databases that can be somewhat well defined (and somewhat not). If things have been slowly iterating over 35 years, there's a lot of undocumented edge behavior that may occur; it may be beneficial to have a step before Edge Case Catalog where there's some kind of prompting to catalogue how the inputs and outputs work, and then find the different inputs and outputs - and then confirm that with Input A and Output A that it works as expected. (Legacy systems often have weird orchestration that nobody remembers.) (Sub-note: This is somewhat part of the provable properties catalog; while this step could be placed there, it would require a re-run of edge case catalog build potentially, which isn't a bad thing.) A small note that I personally think is a good idea is better code commenting than has been outlined here - the spec itself should be woven into the code with potentially slightly over-commenting for each aspect, code spec gets lost. The code itself should serve as context, especially in the TDD stage. I think it's implicit but may be worth overtly stating that for the Code Quality check in Phase 3 that it also checks on a zero-trust basis, and doesn't include things like hardcoded keys. I'm not sure what Chainlink is (sorry!) but I like the ideas outlined around the decomposition - but it misses stringing everything together end-to-end in the way outlined here (it asks to create each part, but never actually weaves the whole together). Something not covered - is sequencing work and decomposition of work. A spec can create multiple dependencies within itself, requiring things to be worked on in a specific order.

galoisscobi 8mo ago

I think this word salad doesn’t have enough buzzwords. Throw in a few more acronyms too.

desireco42 8mo ago

Claude or something different... there is life beyond Claude I assure you and it is quite good and colourful.

mitchbob 8mo ago

Upvoted for the Sarcasmotron.

esafak 8mo ago

This is AI slop not worth my time. What would be interesting is if the author shared her practical experience in implementing it. Let's see some of those specs. What tricky bugs did it catch? The author's latest repo hasn't even been passing CI, so what does that say? https://github.com/dollspace-gay/Tesseract-Vault/commits/main/ https://github.com/dollspace-gay/Tesseract-Vault/commits/mai...

relativeadv 8mo ago
yes, all of the typical signs and symptoms appear to be there. Lists upon sublists of verbose overengineered plausibly thoughtful writing. If you can't be bothered to write it, why should i be bothered to read it?
dollspace 8mo ago
The runners are failing because it moved them from github hosted to self hosted and its requiring fixes, but you would know that if you actually paid attention to the commits and werent just looking for cheap dunks. Have a good one.
- esafak 8mo ago
  I looked at the past few pages of your repo's history and half the time it is broken. Is this continued failure despite using a verified spec, or did you not use one? If not which repo should we look at instead? I am sorry but I see nothing from you to engage here.
  - dollspace 8mo ago
    [dead]

vielite1310 8mo ago

I would like to be enlightened myself if RPI,BMAD or any spec-driven approaches actually worked for any mid/large scale projects, without wasting millions of tokens of course :)

rsrsrs86 8mo ago
Real spec driven uses no tokens

SirensOfTitan 8mo ago

LLM-assisted development feels a lot like trend-driven development. When dealing with technique and heterogenous prompts and goals, it’s easy to gain somewhat of a gambler’s fallacy with respect to a particular technique. Spec-driven development feels pretty questionable to me. I’m sure it works fine for feature work that is predictable or has been done before, but then I wonder why you’d waste your time with it. Prior to LLMs, the whole vibe was to iterate rapidly toward a working thing so you can see what works and what doesn’t. Why would we abandon that strategy as an industry when the cost of writing code is ostensibly getting cheaper? If I’m using LLMs at all, I’m using them to do a breadth search of prior art or ideas, then I’m doing what I might call a prototype onion: successive clean room attempts at a novel problem, accumulating what I learn at each attempt in each successive prompt. I usually then take the prototype and write the final version myself so I’m properly internalizing the idea. Ultimately a lot of this prompt work feels like procrastination. It is not about understanding where these tools is useful and where they are not but trying to have them consume every aspect of the work.

getnormality 8mo ago
Or maybe people who like talking much more than they like code are now very excited about the possibility that talking has eaten software development. This is exactly backwards. For many tasks, formal languages are better, more real, more beautiful than English. No matter how many millions of tokens you have, you will never talk the formulas of Fermat, Euler, and Gauss into irrelevance. And the same is true of good code. Of course, a lot of code is ugly and utilitarian too, and maybe talking will make it less painful to write that stuff.
- skydhash 8mo ago
  > a lot of code is ugly and utilitarian too, And as everyone who can abstract well knows: Ugly code that have staying power have a reason to be ugly. And the best will be annotated with HACK and NOTE comments. Anything else can be refactored and abstracted to a much better form. But that requires a sense of craftsmanship (to know better) and a time allowance for such activity.
- 8mo ago

pron 8mo ago

If you come up with a strategy that seems to "solve programming", then you know for certain there must be a flaw in it, and you need to identify where it is that corners must be cut and how. Computer science is an introspective discipline because it studies the essential difficulty of problems regardless of the process taken to solve them, and programming itself (i.e. the problem of producing a correct, or correct-enough program) is such a problem that can be, and has been studied. The question of learning whether a program X satisfies some correctness property P is known as the model-checking problem, and we know that answering it with certainty is intractable. For example, some properties that are true for some program would take no less than 10 minutes to verify (regardless of how that verification is done), others will take no less than 10 hours, others no less than 10 months, others no less than 10 years and so on, and we don’t know ahead of time whether the proprty is true, and if it is, where on this spectrum it falls. So suppose you decide some property must be proven with full certainty, the question becomes, how long do you wait before giving up waiting for the validation and what do you do when you give up? If you then decide that you’re okay with less than 100% confidence, what approach do you take and how much confidence do you actually have? The problem with that is that the answer to that question often requires a deep understanding of the implementation. I.e. if you have two programs, X and Y, that compute the same function, one less-than-perfect approach would give you 99% confidence with one of them, but only 10% confidence with another.

twoodfin 8mo ago
More, “If your LLM comes up with a strategy to ‘solve programming’ …”

deleted 8mo ago

[deleted]

Robdel12 8mo ago

I’ve gotten the absolute best results from LLMs just acting like the software engineer I’ve aspired to be the past 15 years. Normal dev things. Scope the ticket properly, break it down. Test well. Write the correct docs. LLM specific things are going to be gone next week

twodave 8mo ago
I feel this very recently. I just pretend the agent is a junior dev and tell them to do things I don’t have time for. Reviewing the changes at my convenience is a lot like checking in on a junior dev, too. On the other hand I do feel like I get better results with the same teeing up that a junior dev requires, so I try to remove as many unknowns/dependencies as possible (or else explicitly tell it to leave some things as stubs) before sending him off to do something
- actionfromafar 8mo ago
  Junior devs who know a lot more maths than I do...

beders 8mo ago

> Define the contract before writing a single line of implementation. Specs are the source of truth. There is only one source of truth and that is the source code. To define and change contracts written in an ambiguous language and then hope the right code will magically appear, is completely delusional. Iteration is the only game in town that is fast and produces results.

choeger 8mo ago

If I am not mistaken, the verification is problematic here. It's run too late. A piece of code that satisfies a single test will most likely not be probable to adhere to the spec. Worse, the whole spec can only be correctly implemented in total. You cannot work iteratively by satisfying one constraint after the other. The same holds for the test cases. That means that satisfying the last test or fulfilling the last constraint will take much more work than the first. The number of tests passed is not a good metric for completion of the implementation.

melvinroest 8mo ago

I've been doing something less formal. I stumbled upon Riaan Zoetmulder's free course on deep learning and medical image analysis [1] and found his article on spec-driven development [2]. He adapts the V-Model by specifying three things upfront: requirements, system design and architecture. The rest gets generated. He mentioned a study where they show that LLM assistance slowed down experienced open source devs on large codebases. The model doesn't know the implicit context. And to me that's the thing! An LLM should have an index of some sort. So I vibe coded my own static analysis program where I just track my own function calls. It outputs a call graph of all my self-defined functions and shows the name (and Python type hints) of what it is calling (excluding standard library function, also only self-defined stuff). Running that program and sending the diff from time to time seems to have helped a lot already. [1] https://www.riaanzoetmulder.com/courses/deep-learning-medical-imaging/ https://www.riaanzoetmulder.com/courses/deep-learning-medica... [2] https://www.riaanzoetmulder.com/articles/ai-assisted-programming-project-setup/ https://www.riaanzoetmulder.com/articles/ai-assisted-program...

xcubic 8mo ago
I am not following, can you give a concrete example of your workflow?
- melvinroest 8mo ago
  In my agent file I explain that I have a static analyzer which generates a callgraph. On starting the agent runs ~/.agent/tools/__callgraph__/generate_callgraph.py It then gets to see callgraph.current.md and upon subsequent sessions callgraph.diff.md. Here is an example of some output that I currently have in callgraph.current.md ## src/components/Header.tsx - **export Header({ ... }: Props)** (start 9, end 54) → `useAuth` ## src/components/HelpTooltip.tsx - **export HelpTooltip({ ... }: Props)** (start 15, end 42) → (none) ## src/components/ResultsTable.tsx - **getHeaderLabel(col: { id: string; columnDef: { header?: unknown } }): string** (start 45, end 51) → (none) - **getCellValue(colId: string, original: KeywordResult): string** (start 53, end 74) → (none) - **export ResultsTable({ ... }: Props)** (start 76, end 406) → `getCellValue` ## src/components/SettingsDrawer.tsx - **export SettingsDrawer({ ... }: Props)** (start 158, end 336) → (none) For example: ResultsTable calls getCellValue. In these cases it's just one function but you also have stuff like **export Dashboard()** (start 36, end 635) → `getTopKeywords`, `normalizeText`, `searchKeywords`, `searchKeywordsMulti`, `searchSemantic`, `searchSemanticMulti` For the Python version it also gives the parameters and types along with it. I think the next thing I'd need to do is give self-defined type definitions. Doing things this way allows an LLM to not read all that much but to be able to reason relatively well over what the code does. The caveat is that you abstracted your code well. If you didn't, the LLM doesn't know your implementation. I probably should also add return types.

alpaylan 8mo ago

You cannot escape from the human verifying the properties you want verified mechanically. This only gives you leverage in specific scenarios where specification is much simpler than the implementation.

jatins 8mo ago

The gist is 100% AI written https://www.pangram.com/history/9d89ebba-cdba-40e1-b569-9ae1c2d44c13?ucc=PQCmbwNZf1k https://www.pangram.com/history/9d89ebba-cdba-40e1-b569-9ae1...

WestN 8mo ago

Short take: replace TDD with BDD, and might add DDD as a spice. Otherwise this is a fairly good article. Why not TDD? Since a lot of developers use LLMs to create tests today, plus a lot of the training data contains information on how to do this. Making it something that it either can figure out to do by itself or that it will cheat. Both equally bad. A somewhat controversial take is that you should simply avoid writing tests which the LLM can produce by itself, similar to how we in the last week removed the agents.md file.

chrisweekly 8mo ago
could you say more about removing agents.md?
- supermdguy 8mo ago
  Probably referencing this: https://news.ycombinator.com/item?id=47034087 https://news.ycombinator.com/item?id=47034087
  - chrisweekly 8mo ago
    thanks btw, if you're right, that post's top comment seems to make a strong case for keeping agents.md
esperent 8mo ago
Modern testing frameworks already use BDD (behavior driven development , which simply means writing tests in natural language. BDD is a superset of TDD: import { describe, it, expect } from 'vitest'; describe('User Authentication', () => { it('should allow login with valid credentials', () => { const result = login('user@example.com', 'password123'); expect(result.isAuthenticated).toBe(true); }); This is BDD and every testing framework I've used in my entire career and 95% of the tests I've written look something like that.

daveac 8mo ago

In a perfect world I can see this happening. But with AI increasing or output I think the real bottleneck is work sponsors, business logic and requirements discovery/translating/sign off. I am seeing more teams and features being rolled faster than before but then discovering that the sponsors (those requesting features and change) either don’t invest the time up front or with timely feedback loops and work stalls or has to be redone as business does not see the results until it’s either live or about to go live. This has always been the case but I think AI tooling has moved the bottleneck

rsrsrs86 8mo ago

That’s how I do it, minus the marketing.

teiferer 8mo ago

I expected formal verification to be part of this. That could not be fooled and is rock-solid, unless you cheat in your specification. Swap your AI "verifier" out for that and I'm on board.

mpalmer 8mo ago

Looks moderately interesting, but I refuse to upvote vibe-written submissions. Of course documents like this have their uses, but: - They cannot easily be attributed to a human author, and therefore debates and discussions on the substance of the ideas tend not to get too far - They (tend to) take well-established concepts, glue them together, and describe the result in reverential tones, regardless of the relative triviality of the solution. Hard to rule that out here tbh. I am not saying any of that is what's happening here. What I am saying is that I'm not going to waste my time reading something I can't easily vet for quality. Author (not OP) has written plenty of its* own words on Bluesky over the last few weeks. If it's written anything longhand about this stuff I'd be interested to read it. But for now "anti-slop bias" designed into the system has not reached the prose. *respecting pronouns

FrankRay78 8mo ago

No much different from what I did manually when employer outsourced development to India.

Animats 8mo ago

Is the posting a description of a real system, or just imagination? Is there a link to something that makes this real?

zozbot234 8mo ago
Imagination? More like hallucination - the AI-generated kind.
rsrsrs86 8mo ago
It is very fluffy, but the idea of using formal methods works. It just never settles down… the workflow keeps improving and changing. You don’t need stable tools

jFriedensreich 8mo ago

Its an interesting direction if you see it under the umbrella of diminishing costs: You build a product once with vibe coding and a design/ product hat. Once you know what works you rebuild it 100% in a framework like this. You do this every time from scratch when the tech debt or the mismatch between architecture and needs are too big.

rsrsrs86 8mo ago
I do exactly this. The database schema won’t change as often.
gck1 8mo ago
You could also use the same framework always - that's what I'm doing anyway. But you gotta remember that no matter how well you spec it, first iteration of the specs is going to suck anyway. But you vibe-code it anyway and see what happens. You'll start noticing obvious issues that you can track back to something in spec. Then you throw away the entire thing (the entire project!) and start from scratch. Repeat until you have something you like. Incremental specing doesn't work though. You need a clean room approach with only important learnings from previous iterations. Otherwise agent will never pick a hard but correct path.

johnnyAghands 8mo ago

Does anyone know what Chainlink is?

zellster 8mo ago
I am guessing it is an issue tracker created by the same author. Github link: https://github.com/dollspace-gay/chainlink https://github.com/dollspace-gay/chainlink

dhorthy 8mo ago

software engineering is still software engineering. just because you don't type out the characters doesn't mean you're not designing systems and thinking critically and leveraging your experience. also: do we think this is written by ai? do we care anymore?

tkel 8mo ago
Yes it's very obviously written by AI and made me immediately close the tab. Not gonna read a self-promotional piece written by an LLM that someone probably only gave it one sentence prompt: "merge these ideas".
frez131 8mo ago
I personally care deeply when content intended as communication is AI generated (much more so than if code is generated). On the surface level, I find it a bit disrespectful when I'm communicating with someone who's just using an LLM to generate their responses. Imagine if you are talking to someone in-person, and they pull out a phone, generate a response then read it back out to you? On a deeper level, if someone's generated a bunch of text and clearly hasn't devoted the time into generating/editing it that they're expecting me to invest while reading it, I'm just not going to read it.

syndacks 8mo ago

Does anyone have any solid patterns they can share around the “scenarios”/holdouts concept from the Dark Factory, where you create external system(s) to verify your main one?

xomiachuna 8mo ago
So bdd essentially?

ozozozd 8mo ago

We’re launching markdown now, aren’t we?

mobrienv 8mo ago

Doing something similar with https://github.com/mikeyobrien/ralph-orchestrator https://github.com/mikeyobrien/ralph-orchestrator It's much more than a simple Ralph loop.

vivzkestrel 8mo ago

- you most certainly also wanna read this one https://boristane.com/blog/the-software-development-lifecycle-is-dead/ https://boristane.com/blog/the-software-development-lifecycl...

dworks 8mo ago

I've implemented a version of this in rlm-workflow: https://skills.sh/doubleuuser/rlm-workflow/rlm-workflow https://skills.sh/doubleuuser/rlm-workflow/rlm-workflow

cadamsdotcom 8mo ago

Some of the ideas here are codified in a simpler way in my TDD framework, CodeLeash (https://codeleash.dev https://codeleash.dev). The key difference is CodeLeash puts guardrails outside the model, as Claude Code hooks. It can’t forget or skip steps, it gets forced through a process. There are bypasses but they raise alarms that the model is also forced to review. Putting guardrails outside the model forces deterministic process following. With a sufficiently capable process (TDD is a powerful way to build software) you can really scale up coding agent usage.

virgilp 8mo ago
Cool but it is not a framework for working with AI, it is an _opinionated_ framework for building full-stack apps right? As in, I can't use any of it if I'm building, say, a Spark data processing pipeline. Or a ML framework. Or automation software that runs on custom processors. The idea of "guardrails outside the model" is definitely appealing but I wonder if you can make it generalize well.
- cadamsdotcom 8mo ago
  You’re right of course, the framework is pretty rigidly tied to full stack. But the underlying idea I think has power - find a process you can codify enforcement of rather than telling models how they should do things. Spec driven development probably means creating tooling to track how code maps to specs, for example.. and then working out how to manage that as data. Then you can query the data to confirm all mappings between code and specs. That gets you out of the business of nicely and repeatedly asking very expensive and undependable models such queries :)
tinodb 8mo ago
Nice, I had the same idea for a enforced TDD state machine! I wouldn’t tie it to all the other stuff though, but I might try it out.
- cadamsdotcom 8mo ago
  The TDD guard is the most isolated part of the whole thing, you could just take the files involved and ignore the rest. Maybe 6-7 files all referenced from the .claude/settings.json hook config. Would be glad to see how you go!

hamdouni 8mo ago

So we are cycling back to kind of Waterfall Development ? No more agility ? The trend is dead by AI ?

virgilp 8mo ago
"Waterfall" got a bad rep because it meant "we stay months in the requirements gathering, then months design phase, then months in development, then months in validation". If you compress "months" to days/hours, what you obtain is something that nobody from the 90s would recognize as "waterfall"; it is not the end of agility, far from it.

entrustai 8mo ago

[dead]

euroderf 8mo ago

I don't see any discussion here (in these comments) of requirements management. Is the very idea of RM too organized for people eager to spin up a bunch of LLMs and watch the code generation fly ? Or has RM been tried with LLMs and found lacking ?