Post

The spec is really good - detailed, comprehensive: github.com/openai/symph... Implementations are now easy. Writing excellent specifications becomes the core skill.

This is gathering chatter so I need to clarify: neither openAI nor I is suggesting everyone prompts their own version. Obvs wasteful. Theres a canonical implementation! The important line is “in your programming language of choice”. Where lang could be any number of design prefs and variables.

IF you want to adapt software to fit your needs, run in your pref lang, change the architectural decisions, etc. rather than forking and editing source code, you can adjust at a higher level. Specs are a concise, directionally correct design ref with less complexity than the implementation code.

This is cool. I'm almost more interested in _how_ they wrote the spec. It obviously has a ton of planning and thought. I don't know how to do that. :)

If they had released the code, critics would likely be scouring it for bugs and incoherence – which at 1m loc, it almost certainly has. Sensible move on their part – keeps the discussion on the ideas, and saves them having to own something they like don't want to maintain for general audience.

I'm unclear on how every single installation of this having its very own set of bespoke, inevitable bugs is an improvement over a model where you find a bug and you release a patch for that bug.

The canonical implementation gets patched. And then they update the spec with the patch too. I should have emphasised more the “implement in your programming language of choice” part. Where “own lang” could be any variety of design preferences. So you only prompt bespoke versions when needed.

It's an improvement in that they aren't responsible.

I've been experimenting with spec-driven dev. I think one major upside is that while developing, you don't need to consider every minor detail of the codebase, and instead can focus on high-leverage points that are non-trivial. but as a way to publish a project... I guess its easier to customize?

I fail to understand the reasoning for this. What am I missing? It feels fantastically wasteful to generate the software from scratch using an energy-intensive process each time. What is the benefit over a canonical implementation?

A canonical implementation needs to be maintained. If you vibecode from the spec, they can just say it’s your bugs, not their bugs. The reference implementation is “experimental” for the same reason.

They could opt for the shadcn model and offload ownership. I guess they don't get people spending tokens that way 😅

Same, I've also seen a project with AI-driven codemods instead of some deterministic CLI

Tool calling from agents makes that architecture an especially strange choice. The inverse is strictly better: have an agent call the deterministic tool to do the 80%, then the agent can finish the remaining fuzzy 20%

I’m guessing it could be some clever money-making strategy. Release the spec -> get people to generate the code -> every time someone wants to implement it, they pay OpenAI to generate the code

this seems extremely unrealistic to me. i think it’s going to be a tiny drop in the bucket and not at all relevant in that sense?

there is a canonical implementation (option 2), no? i think the benefit is just that you can specify what’s essential to the idea vs what’s incidental to an implementation (eg language choice, some wiggle room with details etc).

I was more so responding to the general premise in Maggie's commentary than the specifics here

Nobody knows, but it remains an eternal truth of software development. There is an entire universe of redundant JavaScript frameworks out there that all do basically the same thing and were energy expensive expensive efforts. And yet...