19 ms·

A sufficiently detailed spec is code

• ossianericson 7mo ago
  [dead]
• measurablefunc 7mo ago
  I agree with the overall structure of the argument but I like to think of specifications like polynomial equations defining some set of zeroes. Specifications are not really code but a good specification will cut out a definable subset of expected behaviors that can then be further refined with an executable implementation. For example, if a specification calls for a lock-free queue then there are any number of potential implementations w/ different trade-offs that I would not expect to be in the specification.
  • catlifeonmars 7mo ago
    I kind of feel like the specification would call for an idealized lock free queue. Whereas the code would generate a good enough approximation of one that can be run on real hardware. To invert your polynomial analogy, the specification might call for a sine wave, your code will generate a Taylor series approximation that is computable.
    • codebje 7mo ago
      A thorough specification might even include the acceptable precision on the sine wave; a thorough engineer might ask the author what the acceptable precision is if it's omitted.
• notepad0x90 7mo ago
  I agree to this, with the caveat that a standard is not a spec. E.g.: The C or C++ standards, they're somewhat detailed, but even if they were to be a lot more detailed, becoming 'code' would defeat the purpose (if 'code' means a deterministic turing machine?), because it won't allow for logic that is dependent on the implementer ("implementation defined behavior" and "undefined behavior" in C parlance). whereas a specification's whole point is to enforce conformance of implementations to specific parameters.
  • gizmo686 7mo ago
    Even programs are just specifications by that standard. When you write a program in C, you are describing what an abstract C machine can do. When the C compiler turns that into a program it is free to do so in any way that is consistent with the abstract C machine. If you look at what implementions modern compilers actually come up with, they often look quite different from what you would expect from the source code
    • notepad0x90 7mo ago
      I don't disagree, so in a way, compilers are the specification that implement the standard? That doesn't feel right though.
      • skydhash 7mo ago
        Compilers are converters. There’s the abstract machine specified by the standard and there’s the real machine where the program will run (and there can be some layer in between). So compilers takes your program (which assumes the abstract machine) and builds the link between the abstract and the real. If your program was a DSL for steering, the abstract machine will be the idea of steering wheel, while the machine could be a car without one. So a compiler would build the steering wheel, optionally adding power steering (optimization), and then tack the apparatus to steer for the given route.
• ranyume 7mo ago
  I tried myself to make a language over an agent's prompt. This programing language is interpreted in real time, and parts of it are deterministic and parts are processed by an LLM. It's possible, but I think that it's hard to code anything in such a language. This is because when we think of code we make associations that the LLM doesn't make and we handle data that the LLM might ignore entirely. Worse, the LLM understands certain words differently than us and the LLM has limited expressions because of it's limits in true reasoning (LLMs can only express a limited number of ideas, thus a limited number of correct outputs).
• cheevly 7mo ago
  [dead]
• charcircuit 7mo ago
  This articles ignores that AI agents have intelligence which means that they can figure out unspecified parts of the spec on their own. There is a lot of the design of software that I don't care about and I'm fine letting AI pick a reasonable approach.
  • deleted 7mo ago
    [deleted]
  • ChimpWithHat 7mo ago
    Exactly. The real speed up from AI will come when we can under specify a system and the AI uses its intelligence to make good choices on the parts we left out. If you have to spec something out with zero ambiguity you’re basically just coding in English. I suspect current ideas around formal/detailed spec driven development will be abandoned in a couple years when models are significantly better.
    • macinjosh 7mo ago
      For now I would be happy if it just explored the problem space and identify the choices to be made and filtered down to the non-obvious and/or more opinionated ones. Bundle these together and ask the me all at once and then it is off to the races.
    • majormajor 7mo ago
      This is humans have traditionally done with greenfield systems. No choices have been made yet, they're all cheap decisions. The difficulty has always arisen when the lines of code pile up AND users start requesting other things AND it is important not to break the "unintended behavior" parts of the system that arose from those initial decisions. It would take either a sea-change in how agents work (think absorbing the whole codebase in the context window and understanding it at the level required to anticipate any surprising edge case consequences of a change, instead of doing think-search-read-think-search-read loops) or several more orders of magnitude of speed (to exhaustively chase down the huge number of combinations of logic paths+state that systems end up playing with) to get around that problem. So yeah, hobby projects are a million times easier, as is bootstrapping larger projects. But for business works, deterministic behaviors and consistent specs are important.
• rdevilla 7mo ago
  I think it's only a matter of time before people start trying to optimize model performance and token usage by creating their own more technical dialect of English (LLMSpeak or something). It will reduce both ambiguity and token usage by using a highly compressed vocabulary, where very precise concepts are packed into single words (monads are just monoids in the category of endofunctors, what's the problem?). Grammatically, expect things like the Oxford comma to emerge that reduce ambiguity and rounds of back-and-forth clarification with the agent. The uninitiated can continue trying to clumsily refer to the same concepts, but with 100x the tokens, as they lack the same level of precision in their prompting. Anyone wanting to maximize their LLM productivity will start speaking in this unambiguous, highly information-dense dialect that optimizes their token usage and LLM spend...
  • sjeiuhvdiidi 7mo ago
    [dead]
  • nomel 7mo ago
    Let's use a non-ambiguous language for this. May I suggest Lojban [1][2]? [1] https://en.wikipedia.org/wiki/Lojban https://en.wikipedia.org/wiki/Lojban [2] Someone speaking it: https://www.youtube.com/watch?v=lxQjwbUiM9w https://www.youtube.com/watch?v=lxQjwbUiM9w
    • deleted 7mo ago
      [deleted]
    • dooglius 7mo ago
      It looks like that's about syntactic ambiguity, whereas the parent is talking semantic ambiguity
    • mike_hearn 7mo ago
      Lojban allows you to speak ambiguously, it just disallows grammatical ambiguity because in the 70s it was hypothesized that NLP understanding was impossible so humans would have to adapt instead of computers. That debate is over; understanding grammar is solved. The new debate is over semantic ambiguity.
• tomlin 7mo ago
  [dead]
• X95_BNB35 7mo ago
  [dead]
• HoldOnAMinute 7mo ago
  I have a lot of fun making requirements documents for Claude. I use an iterative process until Claude can not suggest any more improvements or clarifications. "Is this it?" "NOPE" https://www.youtube.com/watch?v=TYM4QKMg12o https://www.youtube.com/watch?v=TYM4QKMg12o
• macinjosh 7mo ago
  IMHO, LLMs are better at Python and SQL than Haskell because Python and SQL syntax mirrors more aspects of human language. Whereas Haskell syntax reads more like a math equation. These are Large _Language_ Models so naturally intelligence learned from non-code sources transfers better to more human like programming languages. Math equations assume the reader has context not included in the written down part for what the symbols mean.
  • catlifeonmars 7mo ago
    I suspect your probably right, but just for completeness, one could also make the argument that LLMs are better at writing Haskell because they are overfit to natural language and Haskell would avoid a lot of the overfit spaces and thus would generalize better. In other words, less baggage.
    • travisgriggs 7mo ago
      I would guess they’re better at python and SQL than Haskell because the available training data for python and SQL is orders of magnitude more than Haskell.
  • WanderPanda 7mo ago
    They are heavily post-trained on code and math these days. I don‘t think we can infer that much about their behavior from just the pre-training dataset anymore
  • ozozozd 7mo ago
    They are not called Context-Sensitive Large Language Models though. LLMs are very good at bash, which I’d argue doesn’t read like language or math.
  • dwb 7mo ago
    I have found recent models to be quite respectable at Haskell, given a couple of initial nudges on style - but that’s true of anything.
  • gck1 7mo ago
• adampunk 7mo ago
  Just waterfall harder
• hintymad 7mo ago
  > A sufficiently detailed spec is code This is exactly the argument in Brooks' No Silver Bullet. I still believe that it holds. However, my observation is that many people don't really need that level of details. When one prompts an AI to "write me a to-do list app", what they really mean is that "write me a to-do list app that is better that I have imagined so far", which does not really require detailed spec.
  • ChrisMarshallNY 7mo ago
    But if you’re selling that to-do list app, then the rules are different, and that spec is required. I guess it depends on whether or not we want to make money, or otherwise, compete against others.
  • lmm 7mo ago
    > When one prompts an AI to "write me a to-do list app", what they really mean is that "write me a to-do list app that is better that I have imagined so far", which does not really require detailed spec. If someone was making a serious request for a to-do list app, they presumably want it to do something different from or better than the dozens of to-do list apps that are already out there. Which would require them to somehow explain what that something was, assuming it's even possible.
    • ms_menardi 7mo ago
      It could be an issue of discoverability too. Maybe they just haven't found the to-do app that does what they want, and it's easier to just... make one from scratch.
      • carlmr 7mo ago
        Which is not getting better. I'd pay you 10€ for a TODO app that improved my life meaningfully. It would obviously need to have great UX and be stable. Those are table stakes. I don't have the time to look at all these apps though. If somebody tells me they made a great TODO app, I'm already mentally filtering them out. There's just too much noise here. Does your TODO app solve any meaningful problem beyond the bare minimum? Does it solve your procrastination? Does it remind you at the right time? If it doesn't answer this in the first 2 seconds of your pitch you're out.
• adi_kurian 7mo ago
  This won't age well, or my comment won't age well. We'll see!
  • ex-aws-dude 7mo ago
    It will either be true or not be true That is the great insight I can offer
    • ozozozd 7mo ago
      It is indeed of type boolean.
    • layer8 7mo ago
      Wait, people still believe in the law of excluded middle?
    • adi_kurian 7mo ago
      Mostly, I wrote "this won't age well", then appended the circular comment as I didn't want to sound like an arsehole. Looks like I would have been better off!
• randyrand 7mo ago
  True. That's why I only write assembly. Imagine a piece of software deciding register spill for you! Unhinged!
• pkoird 7mo ago
  Meh, it's the age old distinction between Formal vs Informal language. Simply put: Formal language = No ambiguities. Once you remove all ambiguous information from an informal spec, that, whatever remains, automatically becomes a formal description.
  • manmal 7mo ago
    Is that true though? If I define a category or range in formal language, I’m still ambiguous on the exact value. Dealing with randomness is even worse (eg input in random order), and can’t be prevented in real world programs.
• Panzerschrek 7mo ago
  I am developing my own programming language, but I have no specification written for it. When people tell me that I need a specification, I reply that I already have one - the source code of the language compiler.
  • antonvs 7mo ago
    Maybe this is your point, but the source code of any non-toy compiler is not a usable specification for the language it compiles. If you want a specification from source code, you need to reverse engineer it. Although that’s a bit easier now, with LLMs.
    • Panzerschrek 7mo ago
      What do you mean "usable specification"? Usable to produce another compiler implementation for the same language? This IS possible (like clang was designed to match GCC behavior). Pure specification itself is useless without actual implementation (which does the job), so, trying to write such specification (in a natural language) has no practical sense.
      • antonvs 7mo ago
        You partly answered your own question by mentioning "implementation". Specification and implementation are two different things, and both are important. A specification describes the externally observable behavior, constraints, and properties of a system. That's independent of how those properties are implemented. An implementation is a concrete realization of a specification, that achieves the specified behavior using particular algorithms, data structures, and operational mechanisms. > Pure specification itself is useless without actual implementation (which does the job), so, trying to write such specification (in a natural language) has no practical sense. That's a non sequitur, i.e. the part of your sentence after the commas doesn't follow from the first part. "Pure specification itself" has a purpose, which is to guide implementations. That's the "practical sense".
  • ozozozd 7mo ago
• ulrikrasmussen 7mo ago
  A corollary of this statement is that code without a spec is not code. No /s, I think that is true - code without a spec certainly does something, but it is, by the absence of a detailed spec, undefined behavior.
  • lmm 7mo ago
    On the contrary, code is a spec. In a decent language it should look like one.
    • onion2k 7mo ago
      Code is a specific implementation of a spec. You can even use it as a spec if you're happy to accept exactly what the code does. But the code doesn't tell you what was supposed to be built so the code is not a spec. Simple thought experiment: Imagine you have a spec and some code that implements it. You check it, and find that a requirement in the spec was missed. Obviously that code is not the spec; the spec is the spec. But also you couldn't even use the code as a spec because it was wrong. Now remove the spec. Is the code a spec for what was supposed to be built? No. A requirement was missed. Can you tell from just the code? Also no. You need a two separate sources that tell you what was meant to be written in case the either of them is wrong. That is usually a spec and the code. They could both be wrong, and often are, but that's a people problem.
      • lmm 7mo ago
        > Obviously that code is not the spec; the spec is the spec. But also you couldn't even use the code as a spec because it was wrong. Or the spec was wrong and the code was right; that happens more often than you might think. If we view it through the lens of "you have two specs, one of which is executable" then obviously you could have made an error in either spec, and obviously writing two specs and checking for mismatches between them is one possible way to increase the fidelity of what you wrote, but it's nothing more than that.
        • onion2k 7mo ago
• sjeiuhvdiidi 7mo ago
  Absolute nonsense. A sufficiently detailed "spec" is the code. What is wrong with you people ? Pure nonsense, all they have to offer.
  • tomhow 7mo ago
    Please don't fulminate on HN. The guidelines make it clear we're trying for something better here. https://news.ycombinator.com/newsguidelines.html https://news.ycombinator.com/newsguidelines.html
    • sjeiuhvdiidi 7mo ago
      [dead]
• deleted 7mo ago
  [deleted]
• kikkupico 7mo ago
  Natural language is fluid and ambiguous while code is rigid and deterministic. Spec-driven development appears to be the best of both worlds. But really, it is the worst of both. LLMs are language models - their breakthrough capability is handling natural language. Code is meant to be unambiguous and deterministic. A spec is neither fluid nor deterministic.
  • derrak 7mo ago
    > code is rigid and deterministic I really wish people would start defining what they mean when they say code is deterministic. For instance, code is not deterministic in the sense that it admits a single interpretation when compiled. C code admits many assembly interpretations and the assembly you get will vary depending on your compiler and parameters. When people say code is deterministic I think they mean it has a formal semantics. But these formal semantics may admit any one of many interpretations.
    • kikkupico 7mo ago
      > C code admits many assembly interpretations and the assembly you get will vary depending on your compiler and parameters. There's your own example defining how code is deterministic. Despite being compiled to different assembly interpretations, the code does the same thing.
      • derrak 7mo ago
        All compilations do what I intended to do when I wrote the C code. But each compilation does the intended thing in a different way. The point I’m making is that determinism isn’t the key difference between compilers and LLMs. The key difference is that LLMs do not give semantic guarantees. I don’t care if they give the same output on the same input, just as I don’t care very much which C compiler I use.
        • kikkupico 7mo ago
          > The point I’m making is that determinism isn’t the key difference between compilers and LLMs I think you misunderstood. Determinism is the the difference between natural language and code. It's not about LLMs vs compilers.
• Iamkkdasari74 7mo ago
  [dead]
• ozozozd 7mo ago
  Such amazing writing. And clear articulation of what I’ve been struggling to put into words - almost having to endure a mental mute state. I keep thinking it’s obvious, but it’s not, and this article explains it very elegantly. I also enjoyed the writing style so much that I felt bad for myself for not getting to read this kind of writing enough. We are drowning in slop. We all deserve better!
• lifeisstillgood 7mo ago
  This is laid out in “the code is the design” - https://www.developerdotstar.com/mag/articles/reeves_design_main.html https://www.developerdotstar.com/mag/articles/reeves_design_... by jack reeves. Like they say “everything comes round again”
• cranberryturkey 7mo ago
  [dead]
• causalityltd 7mo ago
  The cognitive dissonance comes from the tension between the-spec-as-management-artifact vs the-spec-as-engineering-artifact. Author is right that advocates are selling the first but second is the only one which works. For a manager, the spec exists in order to create a delgation ticket, something you assign to someone and done. But for a builder, it exists as a thinking tool that evolves with the code to sharpen the understanding/thinking. I also think, that some builders are being fooled into thinking like managers because ease, but they figure it out pretty quickly.
  • causalityltd 7mo ago
    Also, however much you manage the project, eventually you do need to actually "build". You can't deliver on hype alone. Or maybe you can, but only for some news cycles or VC meetings. The user will eventually need the promised product.
• kenjackson 7mo ago
  Code is usually over specified. I recently used AI to build an app for some HS kids. It built what I spec’wd and it was great. Is it what I would’ve coded? Definitely not. In code I have to make a bunch of decisions that I don’t care about. And some of the decisions will seem important to some, but not to others. For example, it built a web page whereas I would’ve built a native app. I didn’t care either way and it doesn’t matter either way. But those sorts of things matter when coding and often don’t matter at all for the goal of the implementation.
• quotemstr 7mo ago
  No, a spec is not code. It's possible to describe simple behavior that's nevertheless difficult to implement. Consider, say, fn sin(x: f16) -> f16 There are only 64k different f16s. Easy enough to test them all. A given sin() is either correct or it's not. Yet sin() here can have a large number of different implementations. The spec alone under-determines the actual code.
  • mungoman2 7mo ago
    Well, the spec can of course define constraints of how the function is implemented.
  • 9rx 7mo ago
    It says a sufficiently detailed spec is code. Your spec lacks details that could be added.
    • quotemstr 7mo ago
      If you're defining "spec" that way, the word is meaningless. The point of a spec is what it doesn't say.
      • 9rx 7mo ago
        It's turtles all the way down. If you write your spec in C you can get pretty detailed into how sin is implemented, but not fully. The compiler is going to take your spec and still do things with it that you didn't say, like optimize it in ways you never imagined possible. If "spec" doesn't imply that, what does it mean to you? Or maybe you are suggesting that C "code" isn't code[1] either? [1] By the original definition of code that is actually quite true, but I think we can agree the term, as normally used, has evolved over the years?
• rahulj51 7mo ago
  For this to be true, we should be able to - Delete code and start all over with the spec. I don't think anyone's ready to do that. - Buy a software product / business and be content with just getting markdown files in a folder.
  • zevisert 7mo ago
    I've heard of people _experimenting_ with deleting their code every day. I haven't heard of being content paying for a product consisting of markdown files. Though I could imagine people paying for agent skill files. But yet, the skills are not the same product as say, linear.
  • midasz 7mo ago
    This and the idea of creating some sort of english-adjacent programming language for LLM's is fun, I guess, but what problem is it solving. Do we really need to go an abstraction higher?
• scuff3d 7mo ago
  I recently left this comment on another thread. At the time I was focused on planning mode, but it applies here. Plan mode is a trap. It makes you feel like you're actually engineering a solution. Like you're making measured choices about implementation details. You're not, your just vibe coding with extra steps. I come from an electrical engineering background originally, and I've worked in aerospace most of my career. Most software devs don't know what planning is. The mechanical, electrical, and aerospace engineering teams plan for literal years. Countless reviews and re-reviews, trade studies, down selects, requirement derivations, MBSE diagrams, and God knows what else before anything that will end up in the final product is built. It's meticulous, detailed, time consuming work, and bloody expensive. That's the world software engineering has been trying to leave behind for at least two decades, and now with LLMs people think they can move back to it with a weekend of "planning", answering a handful of questions, and a task list. Even if LLMs could actually execute on a spec to the degree people claim (they can't), it would take as long to properly define as it would to just write it with AI assistance in the first place.
  • Seattle3503 7mo ago
    I think of "plan" mode as a read-only mode where the LLM isn't chomping at the bit to start writing to files. Rather than being excitable and over-active, it is receptive and listening.
    • scuff3d 7mo ago
      That's not really my point. If you use it that way fine, but in general I'm talking about the idea that can you plan throughly enough in advance to get it to produce tens of thousands of lines of quality working code. Like the author of the article points out, that takes so much effort by the time your done you may as well have just written the code.
• deleted 7mo ago
  [deleted]
• bob1029 7mo ago
  It helps to decouple the business requirements from the technical ones. It's often not possible to completely separate these areas, but I've been on countless calls where the extra technical detail completely drowns out the central value proposition or customer concern. The specification should say who, what, where, when, why. The code should say how. The code will always be an imperfect projection of the specification, and that is a feature. It must be decoupled to some extent or everything would become incredibly brittle. You do not need your business analysts worrying about which SQLite provider is to be used in the final shipped product. Forcing code to be isomorphic with spec means everyone needs to know everything all the time. It can work in small tech startups, but it doesn't work anywhere else.
  • djtango 7mo ago
    A regular person says "I want a house and it must have a toilet" Most people don't specify or know that they want a U bend in their pipes or what kind or joints should be used for their pipes. The absence of U bends or use or poor joints will be felt immediately. Thankfully home building is a relatively solved problem whereas software is everything bespoke and every problem slightly different... Not to mention forever changing
• trane_project 7mo ago
  I've been trying codex and claude code for the past month or so. Here's the workflow that I've ended up with for making significant changes. - Define the data structures in the code yourself. Add comments on what each struct/enum/field does. - Write the definitions of any classes/traits/functions/interfaces that you will add or change. Either leave the implementations empty or write them yourself if they end up being small or important enough to write by hand (or with AI/IDE autocompletion). - Write the signatures of the tests with a comment on what it's verifying. Ideally you would write the tests yourself, specially if they are short, but you can leave them empty. - Then at this point you involve the agent and tell it to plan how to complete the changes without barely having to specify anything in the prompt. Then execute the plan and ask the agent to iterate until all tests and lints are green. - Go through the agent's changes and perform clean up. Usually it's just nitpicks and changes to conform to my specific style. If the change is small enough, I find that I can complete this with just copilot in about the same amount of time it would take to write an ambiguous prompt. If the change is bigger, I can either have the agent do it all or do the fun stuff myself and task the agent with finishing the boring stuff. So I would agree with the title and the gist of the post but for different reasons. Example of a large change using that strategy: https://github.com/trane-project/trane/commit/d5d95cfd331c304ecb46e40e849d12c6c600171f https://github.com/trane-project/trane/commit/d5d95cfd331c30...
  • jiggawatts 7mo ago
    My twist on this is to first vibe code the solution with the aim of immediately replacing it. I’ve found that two to three iterations with various prompts or different models will often yield a surprising solution or some aspect I hadn’t thought of or didn’t know about. Then I throw away most or all of the code and follow your process, but with care to keep the good ideas from the LLMs, if any.
    • 21asdffdsa12 7mo ago
      The hovering selector, throneing over busy agents, picking the chosen parts condemning the rest..
    • 7mo ago
• wazHFsRy 7mo ago
  Maybe an argument can be made that this definitely holds for some areas of the feature one is building. But in ever task there might be areas where the spec, even less descriptive than code, is enough, because many solutions are just „good enough“? One example for me are integration tests in our production application. I can spec them with single lines, way less dense than code, and the llms code is good enough. It may decide to assert one way or another, but I do not care as long as the essence is there. Could be that the truth is somewhere in between?
• jillesvangurp 7mo ago
  It's a great argument against using software design tools (UML and other tools). The process of writing code is creating an executable specification. Creating a specification for your specification (and phrasing it as such) is a bit redundant. The blue print analogy comes up frequently. IMHO this is unfortunate. Because a blueprint is an executable specification for building something (manually typically). It's code in other words. But for laborers, construction workers, engineers, etc. For software we give our executable specifications to an interpreter or compiler. The building process is fully automated. The value of having specifications for your specifications is very limited in both worlds. A bridge architect might do some sketches, 3D visualizations, clay models, or whatever. And a software developer might doodle a bit on a whiteboard, sketch some stuff out on paper or create a "whooooo we have boxes and arrows" type stuff in a power point deck or whatever. If it fits on a slide, it has no meaningful level of detail. As for AI. I don't tend to specify a lot when I'm using AI for coding. A lot of specification is implicit with agentic coding. It comes from guard rails, implicit general knowledge that models are trained one, vague references like "I want red/green TDD", etc. You can drag in a lot of this implicit stuff with some very rudimentary prompting. It doesn't need to be spelled out. I put an analytics server live a few days ago. I specified I wanted one. And how I wanted it to work. I suggested Go might be a nice language to build it in (I'm not a Go programmer). And I went in to some level of detail on where and how/where I wanted the events to be stored. And I wanted a light js library "just like google analytics" to go with it. My prompt wasn't much larger than this paragraph. I got what I asked for and with some gentle nudging got it in a deployable state after a few iterations. A few years ago you'd have been right to scald me for wasting time on this (use something off the shelf). But it took about 20 minutes to one shot this and another couple of hours to get it just right. It's running live now. As far as I can see with my few decades of experience, it's a pretty decent version of what I asked for. I did not audit the code. I did ask for it to be audited (big difference) and addressed some of the suggested fixes via more prompting ("sounds good, do it"). If you are wondering why, I'm planning to build a AI dashboard on top of this and I need the raw event store for that. The analytics server is just a dirt cheap means to an end to get the data where I need it. AI made the server and the client, embedded the client in my AI generated website that I deployed using AI. None of this involved a lot of coding or specifying. End to end, all of this work was completed in under a week. Most of the prompting work went into making the website really nice.
• pjmlp 7mo ago
  Kind of, that is why non-functional requirements exist, because not everything is code.
• barrkel 7mo ago
  There's essential complexity and accidental complexity. A sufficiently detailed spec need only concern itself with essential complexity. Applications are chock-full of accidental complexity.
• ruhith 7mo ago
  [dead]
• brunorsini 7mo ago
  A sufficiently detailed spec was actually a small step in the path to functional code. Then came all sorts of shenanigans, from memory management to syntax hell, which took forever to learn effectively. This stage was a major barrier to entry, and it's now gone — so yeah, things have indeed changed completely.
• EastLondonCoder 7mo ago
  I don’t really find “can the model produce good code?” that interesting anymore. In the right workflow, it plainly can. I’ve gotten code out of LLMs that is not just faster than I’d write by hand, but often better in the ways that matter: tests actually get written, invariants get named, idempotency is considered, error conditions don’t get silently handwaved away because I’m tired or trying to get somewhere quickly. When I code by hand under time pressure, I’m actually more likely to dig a hole. Not because I can’t write code, but because humans get impatient, bored, optimistic and sloppy in predictable ways. The machine doesn’t mind doing the boring glue work properly. But that is not the real problem. The real problem is what happens when an organisation starts shipping code it does not understand. That problem predates LLMs and it will outlive them. We already live in a world full of organisations that ship bad systems nobody fully understands, and the result is the usual quagmire: haunted codebases, slow change, fear-driven development, accidental complexity, and no one knowing where the actual load-bearing assumptions are. LLMs can absolutely make that worse, because they increase the throughput of plausible code. If your bottleneck used to be code production, and now it’s understanding, then an organisation that fails to adapt will just arrive at the same swamp faster. So to me the important distinction is not “spec vs code”. It’s more like: • good local code is not the same thing as system understanding • passing tests are not the same thing as meaningful verification • shipping faster is not the same thing as preserving legibility The actual job of a programmer was never just to turn intent into syntax anyway. Every few decades the field reinvents some story about how we no longer need programmers now: Flow-Matic, CASE tools, OO, RUP, low-code, whatever. It’s always the same category error. The hard part moves up a layer and people briefly mistake that for disappearance. In practice, the job is much closer to iteratively solving a problem that is hard to articulate. You build something, reality pushes back, you discover the problem statement was incomplete, the constraints were wrong, the edge case was actually central, the abstraction leaks, the user meant something else, the environment has opinions, and now you are solving a different problem than the one you started with. That is why I think the truly important question is not whether AI can write code. It’s whether the organisation using it can preserve understanding while code generation stops being the bottleneck. If not, you just get the same bad future as before, only faster, cleaner-looking, and with more false confidence.
• prohobo 7mo ago
  Why is everyone still talking about markdown files as the only form of spec? The argument is true for text-based specs, but that's not the only option. Stop being so text-file-brained? This article is really attacking vague prose that pushes ambiguity onto the agent - okay, fair enough. But that's a tooling problem. What if you could express structure and relationships at a higher level than text, or map domain concepts directly to library components? People are already working on new workflows and tools to do just that! Also, dismissing the idea that "some day we'll be able to just write the specs and the program will write itself" is especially perplexing. We're already doing it, aren't we? Yes, it has major issues but you can't deny that AI agents are enabling literally that. Those issues will get fixed. The historical parallel matters here as well. Grady Booch (co-creator of UML) argues we're in the third golden age of software engineering: - 1940s: abstracted away the machine -> structured programming - 1970s: abstracted away the algorithm -> OOP, standard libraries, UML - Now: abstracting away the code itself Recent interview here: https://www.youtube.com/watch?v=OfMAtaocvJw https://www.youtube.com/watch?v=OfMAtaocvJw Each previous transition had engineers raising the same objections: "this isn't safe", "you're abstracting away my craft". They were right that something was lost, but wrong that it was fatal. Eventually the new tools worked well enough to be used in production.
  • lmm 7mo ago
    > - 1970s: abstracted away the algorithm -> OOP, standard libraries, UML Which was mostly a failure, to the point that there is a major movement towards languages that "abstract away" (in this sense) less, e.g. Rust. Certainly if the creators of UML are saying that AI is great, that gives me more confidence than ever that it's bunk.
    • prohobo 7mo ago
      UML was for various reasons, but libraries? When's the last time you wrote a sorting algorithm? The entire software ecosystem runs on dependencies. That failed? Rust uses crates to import those dependencies, which was one of its biggest innovations.
      • 7mo ago
• motoxpro 7mo ago
  I agree with this so much. And on top of this, I have the strong feeling that LLMs are BETTER at code than they are at english, so not only are you going from a lossy formate to a less-leossy format, you are specifying in a lossy, unskilled format.
• bad_username 7mo ago
  > There is no world where you input a document lacking clarity and detail and get a coding agent to reliably fill in that missing clarity and detail That is not true, and the proof is that LLMs _can_ reliably generate (relatively small amounts of) working code from relatively terse descriptions. Code is the detail being filled in. Furthermore, LLMs are the ultimate detail fillers, because they are language interpolation/extrapolation machines. And their popularity is precisely because they are usually very good at filling in details: LLMs use their vast knowledge to guess what detail to generate, so the result usually makes sense. This doesn't detract much from the main point of the article though. Sometimes the interpolated detail is wrong (and indeterministic), so, if reliable result is to be achieved, important details have to be constrained, and for that they have to be specified. And whereas we have decades of tools and culture for coding, we largely don't have that for extremely detailed specs (except maybe at NASA or similar places). We could figure it out in the future, but we haven't yet.
  • Someone 7mo ago
    > That is not true, and the proof is that LLMs _can_ reliably generate (relatively small amounts of) working code from relatively terse descriptions. LLMs can generate (relatively small amounts of) working code from relatively terse descriptions, but I don’t think they can do so _reliably_. They’re more reliable the shorter the code fragment and the more common the code, but they do break down for complex descriptions. For example, try tweaking the description of a widely-known algorithm just a little bit and see how good the generated code follows the spec. > Sometimes the interpolated detail is wrong (and indeterministic), so, if reliable result is to be achieved Seems you agree they _cannot_ reliably generate (relatively small amounts of) working code from relatively terse descriptions
    • mike_hearn 7mo ago
      Neither can humans, but the industry has decades of experience with how to instruct and guide human developer teams using specs.
      • 7mo ago
• qwertytyyuu 7mo ago
  Called tests yeah
• svara 7mo ago
  The vibe coding maximalist position can be stated in information theory terms: That there exists a decoder that can decode the space of useful programs from a much smaller prompt space. The compression ratio is the vibe coding gain. I think that way of phrasing it makes it easier to think about boundaries of vibe coding. "A class that represents (A) concept, using the (B) data structure and (C) algorithms for methods (D), in programming language (E)." That's decodeable, at least to a narrow enough distribution. "A commercially successful team communication app built around the concept of channels, like in IRC." Without already knowing Slack, that's not decodable. Thinking about what is missing is very helpful. Obviously, the business strategic positioning, non technical stakeholder inputs, UX design. But I think it goes beyond that: In sufficiently complex apps, even purely technical "software engineering" decisions are to some degree learnt from experiment. This also makes it more clear how to use AI coding effectively: * Prompt in increments of components that can be encoded in a short prompt. * If possible, add pre-existing information to the prompt (documentation, prior attempts at implementation).
  • ithkuil 7mo ago
    It's not necessarily just the terseness. Terseness might be a selling point for people who have already invested in training themselves to be fluent with programming languages and the associated ecosystem of tooling. But there is an entire cohort of people who can think about specifying systems but lack the training to sdo so so using the current methods and see a lower barrier to entry in the natural language. That doesn't mean the LLM is going to think on your behalf (although there is also a little bit of that involved and that's where stuff gets confusing) but it surely provides a completely different interface for turning your ideas into working machinery
    • PessimalDecimal 7mo ago
      "[T]here is an entire cohort of people who can think about specifying systems but lack the training to sdo so so using the current methods and see a lower barrier to entry in the natural language." "Specifying" is the load-bearing term there. They are describing what they want to some degree, how how specifically?
• jumploops 7mo ago
  In my experience with “agentic engineering” the spec docs are often longer than the code itself. Natural language is imperfect, code is exact. The goal of specs is largely to maintain desired functionality over many iterations, something that pure code handles poorly. I’ve tried inline comments, tests, etc. but what works best is waterfall-style design docs that act as a second source of truth to the running code. Using this approach, I’ve been able to seamlessly iterate on “fully vibecoded” projects, refactor existing codebases, transform repositories from one language to another, etc. Obviously ymmv, but it feels like we’re back in the 70s-80s in terms of dev flow.
  • yes_man 7mo ago
    > In my experience with “agentic engineering” the spec docs should be longer than the code itself. Natural language is imperfect, code is exact. The latter notion probably is true, but the prior isn’t necessarily true because you can map natural language to strict schemas. ”Implement an interface for TCP in <language>” is probably shorter than the actual implementation in code. And I understand my example is pedantic, but it extends to any unambiguous definitions. Of course one can argue that TCP spec is not determimistic by nature because natural language isn’t. But that is not very practical. We have to agree to trust some axioms for compilers to work in the first place.
    • jumploops 7mo ago
      Thanks, I updated my comment to say “are often longer” because that’s what I see in practice. To your point, there are some cases where a short description is sufficient and may have equal or less lines than code (frequently with helper functions utilizing well known packages). In either case, we’re entering a new era of “compilers” (transpilers?), where they aren’t always correct/performant yet, but the change in tides is clear.
  • stanac 7mo ago
    > The goal of specs is largely to maintain desired functionality over many iterations, something that pure code handles poorly. IMHO this could be achieved with large set of tests, but the problem is if you prompt an agent to fix tests, you can't be sure it won't "fix the test". Or implement something just to make the test pass without looking at a larger picture.
• amtamt 7mo ago
  > On two occasions I have been asked [by members of Parliament], 'Pray, Mr. Babbage, if you put into the machine wrong figures, will the right answers come out?' I am not able rightly to apprehend the kind of confusion of ideas that could provoke such a question. I guess many of us quality for british parliament.
  • jumploops 7mo ago
    Funnily enough, with the most recent models (having reduced sycophancy), putting in the wrong assumptions often still leads to the right output.
  • IanCal 7mo ago
    I cannot shake the feeling that with that quote the people were trying to point out a problem with something he’d said. “With this machine, all the results will be correct, no more errors in log tables” “And what if people put the wrong figures in?” (Hint - we’d still have the wrong results) Babbage walks away thinking them an idiot, they walk away thinking Babbage hasn’t considered anything outside of the machine itself.
    • amtamt 7mo ago
      Even two wrong, but countering, inputs can sometimes provide right answer, so the rational above has some merit. But if I interpret the question with line of thinking "should I anticipate right/ full answers despite incorrect/ incomplete inputs?" I think Baggage was pointing out the problem in the logic why such questions should arise. I would expect the question to be phrased "under what circumstances the machine with provide wrong outputs?", and would have hoped for Babbage (or may be anyone) explaining many ways how things could go wrong.
  • billynomates 7mo ago
    Maybe the joke was on Babbage. Possible that they were asking about trust and over-reliance, which turned out to be the real problem.
• ACV001 7mo ago
  I don't agree. The code is much more than the spec. In fact, the typical project code is 90% scaffolding and infrastructure code to put together and in fact contains implementation details specific to the framework you use. And only 10% or less is actual "business logic". The spec doesn't have to deal with language, framework details, so by definition spec is the minimum amount of text necessary to express the business logic and behaviour of the system.
  • duesabati 7mo ago
    With ALL due respect (seriously), this is just a misconception of yours. When you write software to solve a problem you start with as little as possible details such that when you read it, it would only talk about the business logic. What I mean by that? That you abstract away any other stuff that does not concern the domain you are in, for example your first piece of code should never mention any kind of database technology, it should not contain any reference to a specific communication layer (HTTP for example), and so on. When you get to this, you have summarized the "spec", and usually it can be read very easily by a non-techincal person (but obviously is a "domain expert") and can also be very testable. I hope this helps on why the author is right 100%
    • skydhash 7mo ago
      Aka essential and accidental complexity. Most good code will abstract the latter, even if it’s only a shim.
  • quietbritishjim 7mo ago
    I agree. Simple example: if you have a program written with MySQL as the backend, in most cases you could switch to e.g. Postgres and still meet the spec in every meaningful sense of spec. Will the code change? More than just a find/replace of "MySQL" to "Postgres"? Of course.
• angry_octet 7mo ago
  A spec is an envelope that contains all programs that comply. Creating this spec is often going to be harder than writing a single compliant program. Since every invocation of an LLM may create a different program, just like people, we will see that the spec will leave much room for good and bad implementations, and highlight the imprecision in the spec. Once we start using a particular implementation it often becomes the spec for subsequent versions, because it's interfaces expose surface texture that other programs and people will begin to rely on. I'm not sure how well LLMs will fare are brownfield software development. There is no longer a clean specification. Regenerating the code from scratch isn't acceptable. You need TPS reports.
  • abainbridge 7mo ago
    > A spec is an envelope that contains all programs that comply. Creating this spec is often going to be harder than writing a single compliant program. This perfectly explains the feeling I had when, 20 years into my career, I had to start writing specs. I could never quite put my finger on why it was harder than coding. My greater familiarity with coding didn't seem a sufficient explanation. When writing a line of spec, I had to consider how it might be interpreted in the context of different implementations of other lines of spec - combinatorial nightmare. But code is just a spec as far as, say, a C compiler is concerned. The compiler is free to implement the assembly however it likes. Writing that spec is definitely easier than writing the assembly (Fred Brookes said this, so it must be true). So why the difference?
    • skydhash 7mo ago
      > But code is just a spec as far as, say, a C compiler is concerned. The compiler is free to implement the assembly however it likes. Not at all. Code is formal, and going from C to assembly os deterministic. While the rules may be complex, they are still rules, and the compiler can’t stray away from them. Writing C code is easier than writing assembly because it’s an easier notation for thinking. It’s like when hammering a nail. Doing it with a rock is hard. But using a hammer is better. You’re still hitting the nail with a hard surface, but the handle, which is more suitable for a human hand, makes the process easier. So programming languages are not about the machine performance, they are about easier reasoning. And good programmers can get you to a level above that with proper abstraction and architecture, and give you concepts that directly map to the problem space (Gui frameworks instead of directly rendering to a framebuffer, OS syscall instead of messing with hardware,…).
• seedpi 7mo ago
  [dead]
• CraigJPerry 7mo ago
  >> Misconception 1: specification documents are simpler than the corresponding code I used to be on that side of the argument - clearly code is more precise so it MUST be simpler than wrangling with the uncertainty of prose. But precision isn't the only factor in play. The argument here is that essential complexity lives on and you can only convert between expressions of it - that is certainly true but it's is overlooking both accidental complexity and germane complexity. Specs in prose give you an opportunity to simplify by right-sizing germane complexity in a way that code can't. You might say "well i could create a library or a framework and teach everyone how to use it" and so when we're implementing the code to address the essential complexity, we benefit from the germane complexity of the library. True, but now consider the infinite abstraction possible in prose. Which has more power to simplify by replacing essential complexity with germane complexity? Build me a minecraft clone - there's almost zero precision here, if it weren't for the fact that word minecraft is incredibly load bearing in this sentence, then you'd have no chance of building the right thing. One sentence. Contrast with the code you'd have to write and read to express the same.
• ur-whale 7mo ago
  > A sufficiently detailed spec is code Posting something like this in 2026: they must not have heard of LLMs. And also: this is such a typical thing a functional programmer would say: for them code is indeed a specification, with strictly no clue (or a vague high level idea at most) as to how the all effing machine it runs on will actually conduct the work. This is not what code is for real folks with real problems to solve outside of academic circles: code is explicit instructions on how to perform a task, not a bunch of constraints thrown together and damned be how the system will sort it out. And to this day, they still wonder why functional programming almost never gets picked up in real world application.
  • Gabriel439 7mo ago
    Author here: not only have I heard of LLMs but I built a domain-specific programming language for prompt engineering: https://github.com/Gabriella439/grace https://github.com/Gabriella439/grace
• d--b 7mo ago
  > Misconception 1: specification documents are simpler than the corresponding code That is simply not true. There is a ton of litterature around inherent vs accidental complexity, which in an ideal world should map directly to spec vs code. There are a lot of technicalities in writing code that a spec writer shouldn't know about. Code has to deal with the fact that data is laid out a certain way in ram and on disk, and accessing it efficiently requires careful implementation. Code has to deal with exceptions that arise when the messiness of the real world collides with the ideality of code. It half surprises me that this article comes from a haskell developer. Haskell developers (and more generally people coming from maths) have this ideal view of code that you just need to describe relationships properly, and things will flow from there. This works fine up to a certain scale, where efficiency becomes a problem. And yes, it's highly probable that AI is going to be able to deal with all the accidental complexity. That's how I use it anyways.
• jibal 7mo ago
  A piece of code is only one of many different implementations of a spec. And a good spec is careful to state what sort of variation is allowed and when rigid adherence is required.
• TeeWEE 7mo ago
  There are two kid of specs, formal spec, and "Product requirements / technical designs" Technical design docs are higher level than code, they are impricise but highlight an architectural direction. Blanks need to be filled in. AI Shines here. Formal specs == code Some language shine in being very close to a formal spec. Yes functional languages. But lets first discuss which kind of spec we talk about.
• gethwhunter34 7mo ago
  [dead]
  • duesabati 7mo ago
    You mean as arguments that proves the author's pov? Yeah definitely
• nsnzjznzbx 7mo ago
  Not really. Since a lot of code are tradeoffs and decisions made by programmers but the business spec is met either way.
• openclaw01 7mo ago
  [dead]
• spacecadet 7mo ago
  Writing code doesn't reliably work... However, as we converge toward a more collaborative development environment, code is more important than ever. Testing, sales, etc. more important than ever. Security... more important them ever. Or everything will converge toward a rust like inference optimized gibberish...
• firemelt 7mo ago
  just like what djikstra said
• ptman 7mo ago
  I've heard various suggestions of only committing spec.md or change requests in the git repo and using that as source of truth. We have spent decades working on reproducible builds or deterministic compilation. To achieve this, all steps must be deterministic. LLMs are not deterministic. You need to commit source code.
• sornaensis 7mo ago
  Trying to go the Spec -> LLM route is just a lost cause. And seems wasteful to me even if it worked. LLM -> Spec is easier, especially with good tools that can communicate why the spec fails to validate/compile back to the LLM. Better languages that can codify things like what can actually be called at a certain part of the codebase, or describe highly detailed constraints on the data model, are just going to win out long term because models don't get tired trying to figure this stuff out and put the lego bricks in the right place to make the code work, and developers don't have to worry about UB or nasty bugs sneaking in at the edges. With a good 'compilable spec' and documentation in/around it, the next LLM run can have an easier time figuring out what is going on. Trying to create 'validated english' is just injecting a ton of complexity away from the area you are trying to get actual work done: the code that actually runs and does stuff.
• speefers 7mo ago
  [dead]
• __alexs 7mo ago
  Yes and LLMs can iterate and help you refine that spec more quickly.
• fmap 7mo ago
  I agree with most of what the author is saying, but the slogan that "a sufficiently detailed spec is code" can be misunderstood as "a sufficiently detailed spec is a program". The statement is only true if you read "code" as "statement in a formal language". Here's a (sketch of a) specification for a compiler: > For every specification satisfied by the input program, the output program satisfies the same specification. This is not a program and it does not become a program once you fill in the holes. Making the statement precise clearly requires a formal language, but that language can work at a higher level of abstraction than a programming language. So yes, a specification can absolutely be simpler than a program that implements it.
  • skydhash 7mo ago
    But that is not a specification for a compiler. That is just one of the requirement. It’s still missing all the error cases that can happen. Granted, most of those decisions will be taken at implementation time or during design discussions, but I believe if we noted them down, it would have been longer than the code. It’s just that people don’t bother and refer to the code for these kind of information.
    • derrak 7mo ago
      > if we noted them down, it would have been longer than the code If you are only noting down requirements of what the program is doing rather than how it should do that thing, I would expect that writing the requirements would necessarily be more succinct than writing the program. It terrifies me every time I realize people are just jumping into writing code without specifying what that code is required to do. A day of hacking saves an hour of critical thought and planning.
• itmitica 7mo ago
  Good engineering has one loop. Hand coding and codegen are just different workers inside that loop.
• jongjong 7mo ago
  This is relatable. I did a side project with a non-technical co-founder a year ago and every time he told me what he wanted, I made a list of like 9 or 10 logical contradictions in his requirements and I had to walk him through what he said with drawings of the UI so that he would understand. Some stuff he wanted me to do sounded good in his head but once you walk through the implementation details, the solution is extremely confusing for the user or it's downright physically impossible to do based on cost or computational resource constraints. Sure, most people who launched a successful product basically stumbled onto the perfect idea by chance on the first attempt... But what about the 99% others who fell flat on their face! You are the 99% and so if you want to succeed by actual merit, instead of becoming a statistic, you have to think about all this stuff ahead of time. You have to simulate the product and business in detail in your mind and ask yourself honestly; is this realistic? Before you even draw your first wireframe. If you find anything wrong with it, anything wrong at all; it means the idea sucks. It's like; this feature is too computationally and/or financially expensive to offer for free and not useful enough to warrant demanding payment from users... You shouldn't even waste your time with implementation; it's not going to work! The fundamental economics of the software which exists in your imagination aren't going to magically resolve themselves after implementing in reality. Translating an idea to reality never resolves any known problems; it only adds more problems! The fact is that most non-technical people only have a very vague idea of what they want. They operate in a kind of wishy washy, hand-wavy emotion-centric environment and they think they know what they're doing but they often don't.
  • serallak 7mo ago
    He wanted seven perpendicular lines ?
    • jongjong 7mo ago
      Haha. I was like "Glad you've got this 4D chess going on in your head but the user can only see in 3D, buddy."
• ModernMech 7mo ago
  I’d say it differently - that without code the spec is insufficient. Maybe you don’t need a full program as the spec but without some code, you’re left trying to be precise in natural language and that’s not what they are good for.
• xinan 7mo ago
  I’ve noticed that the so-called industry is always fixated on the most crappy language. First it was JavaScript, then Python, now English. They have the common problem of being too flexible and ambiguous, causing bugs that are incredibly hard to find. Yet somehow they always become the most popular, and there’s always a cult about it, mostly consist of people who aren’t real computer scientists. “This time is different” are the famous last words.
• MartinezOnCha24 7mo ago
  [dead]
• zteppenwolf 7mo ago
  No. Code will contain bugs, won't be self-contained (will depend on 3rd party libraries and frameworks), and often will not be complete as TODO features can't possibly be a spec
• justboy1987 7mo ago
  [flagged]
• lo_fye 7mo ago
  So you think CodeSpeak by the creator of Kotlin will fail, pure and simple? https://codespeak.dev https://codespeak.dev
  • j_w 7mo ago
    Yes.
• randusername 7mo ago
  Safety-critical perspective: Specification means requirements. I like EARS [0] syntax for requirements. e.g. "while an error is present, the software shall ignore keypresses" Requirements are not code at all, they are expectations about what the code does; it is the contract about what developers will be held accountable to. Putting implementation details in requirements is a rookie mistake because it takes agency away from the engineers in finding the best solution. The spec discussed in this article is more akin to the level of detail appropriate in an interface control document (ICD). Very common for a requirement to declare the software shall be compliant to a revision of an ICD. My own thoughts are: like a good systems engineer that recognizes the software engineers know their domain better than they, we should write specification for AI that leaves room for it to be more clever than we ourselves are. What's the point of exhaustive pseudocoding, it's worse coding. Align on general project preferences, set expectations, and concentrate effort on verifying. [0]: https://alistairmavin.com/ears/ https://alistairmavin.com/ears/
  • zombot 7mo ago
    > for AI that leaves room for it to be more clever than we ourselves are. How probable is that given that LLMs output the average of their training data? Your own cleverness would have to be below average for this to hold.
    • derrak 7mo ago
      > LLMs output the average of their training data I think it follows that if you ask it to implement something, it will implement the average thing. But then it also follows that if you give it the average thing and ask it to improve it by doing something clever, it may identify a clever improvement if such an improvement has ever been done in an analogous setting that exists in its training set. > Your own cleverness would have to be below average In this case the difference between myself and the LLM is that I’ve never seen the clever thing before (or I cannot recall it as effectively), but the LLM has and the LLM is specialized to recall it
• tomasz-tomczyk 7mo ago
  I'm using obra superpowers plugin in CC and the plans it produces are very code-heavy, which is great for reviewing - I catch issues early. It's quite verbose however and if your codebase moves quickly, the code might have bad/stale examples. Those very detailed specs then let agents run for a long time without supervision so nice for multi tasking :)
• ngriffiths 7mo ago
  I think in an ideal world, programming languages[1] would allow you to express key behaviors, interfaces, states, etc very precisely and sharpen your own understanding while writing, but importantly, also leave unimportant behaviors, structures, etc unspecified, using reasonable defaults and similar stuff. I sort of see the success of coding agents as not just a sign that people get tricked by slop, but mainly a sign that today's languages and frameworks just aren't that good. And now it's easier to say to the LLM, "I literally don't care how the UI is organized as long as everything is visible" than to try to express that in code. [1]: I mean this in the vaguest sense, so including DSLs/frameworks/interfaces offered by libraries too
• silent_cal 7mo ago
  If you think of yourself as a "programmer" or "coder" I think it's fair to say you might have incorrectly defined your role already. Your job is to design and implement software solutions that are reliable and compliant, and make business processes more efficient. Writing code should really be a relatively small piece of the puzzle, and arguably if you're spending a lot of time writing code, you're wasting time. Writing code has always been a means to an end of getting the job done, and I consider being really interested in the practice of coding to be a bit odd. It's as if a carpenter got really into manual saws and got upset about an electric power saw because he "loves manual saws". Whether or not an AI spec is "code" really shouldn't matter if you're a software professional. You are designer/engineer of software systems, not a "coder".
  • enraged_camel 7mo ago
    From 2011, a timeless classic: https://www.kalzumeus.com/2011/10/28/dont-call-yourself-a-programmer/ https://www.kalzumeus.com/2011/10/28/dont-call-yourself-a-pr...
  • jarjoura 7mo ago
    Not quite. Let’s first agree that code is the final output of a software engineer, and that a wooden object is the final output of a carpenter. A correct analogy would be, if a software engineer’s AI assisted output is reduced to assembling auto generated code snippets into a workable product, a carpenters is assembling ikea furniture. The only missing piece is liability. The engineer and carpenter are both hired to assemble something, so they better damn well fully understand what they are delivering because they are being paid to own the liability if anything fails.
  • deleted 7mo ago
    [deleted]
  • contextfree 7mo ago
    this feels to me like "read the room" "not a good look" "don't you know it's uncool to be into that?"
• AliEveryHour16 7mo ago
  [dead]
• minnzen 7mo ago
  [dead]
• qcautomation 7mo ago
  [flagged]
• nudpiedo 7mo ago
  > Misconception 1: specification documents are simpler than the corresponding code Anyone who studied software engineering, should know that specification doesn’t bother with implementation details of the underlying technology. Things such as quite specific engine are used, are the contents of an encapsulated subsystem. Proper software engineering specification is incompatible with a hacker culture and picking technology beforehand is a bad practice. It’s much closer to waterfall than to C4. However, the last 20 years we got software building blocks which impose system architectural restrictions: frameworks. And also pieces of software which are half cooked systems. Far are the days of requirements, preconditions, postconditions and invariants, network diagrams and entity relationship models.
• ppeetteerr 7mo ago
  Too much of code is data transformation. input -> sanitation -> db -> consumer -> api -> client. Business logic defines the shape of that data and some service-level rules but the majority is just shoveling data.
• bombcar 7mo ago
  Sufficiently detailed code is the spec. https://xkcd.com/1172/ https://xkcd.com/1172/
• mohamedkoubaa 7mo ago
  This holds in the opposite direction. Why should an LLM rtfm when it could just as well read the implementation? Of course, you might need a copy of the code in your workspace that it can index, and that usually isn't a problem
• brucer42 7mo ago
  Motivated to create account by Dyjkstra and Borges quotes. Partially read. Hoping for Chuang Tzu.
• AnalyticsData50 7mo ago
  [dead]
• OutOfHere 7mo ago
  It's a bad argument because it misses the point that a spec isn't meant to be 100% detailed. A spec is only meant to contain just the amount of detail that matters to you, leaving the rest to the AI to decide when coding. Of course I also use the AI to refine the spec, but again not to 100% detail, only to ensure I truly cover all that matters to me.
• jason_oster 7mo ago
  A sufficiently detailed spec is not code. It's documentation containing a wealth of information that the code cannot. Code describes how a product works, not what it is supposed to do. That is the job of the specification [1] [2]. Notably, the specification omits implementation details. That is the job of the code. Confusing the *how* and the *what* is very common when discussing specifications, in my experience. Programmers gravitate toward pseudocode when they have trouble articulating a functional requirement. > Specifications were never meant to be time-saving devices. Correct. Anyone selling specifications as a way to save time does not understand the purpose of a specification. Unfortunately, neither does the article's author. The article is based on a false premise. LLMs experience the same problems as humans when provided with underspecified requirements. That's a specification problem. [1]: https://en.wikipedia.org/wiki/Software_requirements_specification https://en.wikipedia.org/wiki/Software_requirements_specific... [2]: https://en.wikipedia.org/wiki/Formal_specification https://en.wikipedia.org/wiki/Formal_specification
• gck1 7mo ago
  It seems like everyone has a very different idea of what spec means in agentic coding. To me, spec answers the what, the plan answers the how, and in what order, build packets answer the how but with more granularity. In most cases, you should only care about the what. How it gets done (plan) is simply an implementation detail that you should not care about the same way automated tests should not care about them. What you prescribe in spec is that data must pass from A to B through C, preserved in D and presented in E in shape of F. It's much easier to write (and change) this in spec than in say, Rust.
• odziggy 7mo ago
  [dead]