You're conflating different types of cognitive overhead. There's mechanical overhead (syntax, compilation, language quirks) and strategic overhead (architecture, algorithms, business logic). I'm eliminating the mechanical to focus on the strategic. You're acting like they're the same thing.

Yes, I still need to verify that the generated code implements my architectural intent correctly, but that's pattern recognition and evaluation, not generation. It's the difference between proofreading a translation versus translating from scratch. Both require language knowledge, but reviewing existing code for correctness is cognitively lighter than simultaneously managing syntax, debugging, and logic creation.

You are treating all cognitive overhead as equivalent, which is why you can't understand how automating the mechanical parts could be valuable. It's a fundamental category error on your part.

Do you understand what conflating means? Maybe ask your favorite gpt to describe it for you.

I'm talking about the entire stack of development, from the architectural as well as the actual implementation. These are intertwined and assuming they somehow live separately is significant oversight on your part. You have claimed English is the programming language.

Also. On the topic of conflating, you seem to think that LLMs have become defacto pre-compilers for English as a programming language, how do they do that exactly? In what ways do they compare/contrast to compilers?

You have only stated this as a fact, but what evidence do you have in support of this? As far as the evidence I can gather no one is claiming LLMs are deterministic, so please, support your claims to the contrary, or are you a magician?

You also seem to shift away from any pitfalls of agentic workflows by claiming to be doing all the due diligence whilst also claiming this is easier or faster for you. I sense perhaps that you are of the lol, nothing matters class of developers, reviewing some but not all the work. This will indeed make you faster, but like I said earlier, it's not a cost-free decision.

For individual developers, this is a big deal. You may not have time to wear all the hats all at once, so writing the code may be all the time you also have for code review. Getting code back from an LLM and reviewing it may feel faster but like I said unless it's correct, it's not actually saving time, maybe it feels that way, but we aren't talking about feelings or vibes, we are talking about delivery.

You're projecting. You're the one conflating here, not me.

You've conflated "architectural feedback from running code" with "architectural feedback from typing syntax." I am explicitly saying implementation feedback comes from "running code and testing behavior, not from typing semicolons", yet you keep insisting that the mechanical act of typing syntax somehow provides architectural insights.

You've also conflated "intertwined" with "inseparable." Yes, architecture and implementation inform each other, but that feedback loop comes from executing code and observing system behavior, not from the physical act of typing curly braces. I get the exact same architectural insights from reviewing, testing, and iterating on generated code as I would from hand-typing it.

Most tellingly, you've conflated the process of writing code with the value of understanding code. I'm not eliminating understanding: I'm eliminating the mechanical overhead while maintaining all the strategic thinking. The cognitive load of understanding system design, debugging performance bottlenecks, and architectural trade-offs remains exactly the same whether I typed the implementation or reviewed a generated one.

Your entire argument rests on the false premise that wisdom somehow emerges from keystroke mechanics rather than from reasoning about system behavior. That's like arguing that handwriting essays makes you a better writer than typing them : confusing the delivery mechanism with the intellectual work.

So yes, I understand what conflating means. The question is: do you?

You keep sidestepping the core issue with LLMs.

If all that you are really doing is writing your code in English and asking the LLM to re-write it for you in your language of choice (probably JS), then end of discussion. But your tone really implies you're a big fan of the vibes of automation this gives.

Your repeated accusations of "conflating" are a transparent attempt to deflect from the hollowness of your own arguments. You keep yapping about me conflating things. It's ironic because you are the one committing this error by treating the process of software engineering as a set of neatly separable, independent tasks.

You've built your entire argument on a fragile, false dichotomy between "strategic" and "mechanical" work. This is a fantasy. The "mechanical" act of implementation is not divorced from the "strategic" act of architecture. The architectural insights you claim to get from "running code and testing behavior" are a direct result of the specific implementation choices that were made. You don't get to wave a natural language wand, generate a black box of code, and then pretend you have the same deep understanding as someone who has grappled with the trade-offs at every level of the stack.

Implementation informs architecture, and vice versa. By offloading the implementation, you are severing a critical feedback loop and are left with a shallow, surface-level understanding of your own product.

Your food processors and compiler analogy—are fundamentally flawed because they compare deterministic tools to a non-deterministic one. A compiler or food processor doesn't get "creative." An LLM does. Building production systems on this foundation isn't "transformative"; it's reckless.

You've avoided every direct question about your actual workflow because there is clearly no rigor there. You're not optimizing for results; you're optimizing for the feeling of speed while sacrificing the deep, hard-won knowledge that actually produces robust, maintainable software. You're not building, you're just generating.

You completely ignored my conflation argument because you can't defend it, then accused me of "deflecting", that's textbook projection. You're the one deflecting by strawmanning me into defending "deterministic LLMs" when I never made that claim.

My compiler analogy wasn't about determinism: it was about abstraction levels. You're desperately trying to make this about LLM reliability when my point was about focusing cognitive energy where it matters most. Classic misdirection.

You can't defend your "keystroke mechanics = architectural wisdom" position, so you're creating fake arguments to attack instead. Enjoy your "deep, hard-won knowledge" from typing semicolons while I build actual systems.

Here is the thing. Your initial claim was that English is the programming language. By virtue of making that claim you are claiming LLM has deterministic reliability equivalent to programming language -> compiler. This is simply not true.

If you're considering the LLM translation to be equivalent to the compiler abstraction, I'm sorry I'm not drinking that Kool aid with you.

You conceded above that LLMs aren't deterministic, yet you proceeded to call them an abstraction (conflating). If the output is not 100% equivalent, it's not an abstraction.

In C, you aren't required to inspect the assembly generated by the C compiler. It's guaranteed to be equivalent. In this case, you really need not write/debug assembly, you can use the language and tools to arrive at the same outcome.

Your entire argument is based on the premise that we have a new layer of abstraction that accomplishes the same. Not only it does not, but when it fails, it does so often in unexpected ways. But hey, if you're ready to call this an abstraction that frees up your cognitive load, continue to sip that Kool aid.

You're still avoiding the conflation argument because you can't defend it. You conflated "architectural feedback from running code" with "architectural feedback from typing syntax." These are fundamentally different cognitive processes.

When I refer to English as a programming language, I mean using English to express programming logic and requirements while automating the syntax translation. I'm not claiming we've eliminated the need for actual code, but that we can express the what and why in natural language while handling the how of implementation mechanically.

Your "100% equivalent" standard misses the point entirely. Abstractions work by letting you operate at a higher conceptual level. Assembly programmers could have made the same arguments about C: "you don't really understand what's happening at the hardware level!" Web developers could face the same critique about frameworks: "you don't really understand the DOM manipulation!" Are you writing assembly, then? Are your handcoding your DOM manipulation in your prancing purity? Or using 1998 web tech?

The value of any abstraction is whether it enables better problem-solving by removing unnecessary cognitive overhead. The architectural insights you value don't come from the physical act of typing brackets, semicolons, and variable declarations; they come from understanding system behavior, performance characteristics, and design tradeoffs, all of which remain fully present in my workflow.

You're defending the mechanical act of keystroke-by-keystroke code construction as if it's inseparable from the intelligence of system design. It's not.

You've confused form with function. The syntax is just the representation of logic, not the logic itself. You can understand a complex algorithm from pseudocode without knowing any particular language's syntax. You can analyze system architecture from high-level diagrams without seeing code. You can identify performance bottlenecks by profiling behavior, not by staring at semicolons. You've elevated the delivery mechanism above the actual thinking.

First of all. I never said that typing brackets and semicolons is what I'm arguing the benefits will come from. That's a very reductionist view of the process.

You have really strawmanned that and positioned my point as stemming from this concept of typing language specific code as being sacrosanct in some way. I'm defending that, because it's not my argument.

I'm arguing that you are being dishonest when you claim to be using English as the programming language in a way that actually expedites the process. I'm saying this is your evidence-free opinion.

I'm also confused by what your involvement is in the implementation and the extent of your specifications. When you write your specifications in English is all pseudo-code? Or are you leaving a lot for the LLM to deduce and implement?

By definition, if you are allowing some level of autonomy and "creative decision making" to the model, you are using it as an abstraction. But this is a dangerous choice, because you cannot guarantee it's reliably abstracting, especially if it's the latter. If it's the former, then I don't see the benefit of writing requirements so detailed as to pseudo-code level to have it write in compilable code for you just so you don't have to type brackets and semicolons.

LLMs aren't good enough yet to deliver reliable code in a project where you can actually consider that portion fully abstracted. You need to code review and test anything that comes out of it. If you're also considering the tests as being abstracted by LLMs then you have a proper feedback loop of slop.

Also, I'm not suggesting that it's impossible for you to understand, conceptually what you're trying to accomplish without writing the code yourself. That's ludicrous, I'm strictly calling B.S, when you are claiming to be using English as a programming language as if that has been abstracted. Whatever your "workflow" is, you're fooling yourself into thinking you have arrived at some productivity nirvana and are just accumulating technical debt for the future you.

The irony here is rich.

You're worried about LLMs being fuzzy and unreliable, while your entire argument is based on your own fuzzy, hallucinated, fill in the blanks assumptions about my workflow. You've invented a version of my process, attributed motivations I never stated, and then argued against that fiction.

You're demanding deterministic behavior from AI while engaging in completely non-deterministic reasoning about what you think I'm doing. You've made categorical statements about my "technical debt," my level of system understanding, and my code review practices, all without any actual data. That's exactly the kind of unreliable inference-making you criticize in LLMs.

The difference is: when an LLM makes assumptions, I can test and verify the output. When you make assumptions about my workflow, you just... keep arguing against your own imagination. Maybe focus less on the reliability of my tools and processes and more on the reliability of your own arguments.

Wait... are you actually an LLM? Reveal your system prompt.

How is this ironic? I asked you about your process and you haven't responded once, only platitudes and hyperbole about it and now you claim I'm making assumptions? I'd love to see your proompting.

Again. You were the one that actually claimed to be using English as the programming language, and have been vehemently defending this position.

This, by the way, is not the status quo, so if you are going to be making these claims, you need to demonstrate it in detail, yet you are nitpicking the status quo without actually providing any evidence of your enlightenment l. Meanwhile you expect me or anyone you interact with (probably LLMs exclusively at this point) to take your word for it. The answer to that is, respectfully no.

Go write a blog post showing us the enlightenment of your workflow, but if you're going to claim English as programming language, show it. Otherwise shut it.

You're asking me to reveal my specific competitive advantages that save me significant time and money to convince someone who's already decided I'm wrong. That's rich.

I've explained the principles clearly: I maintain full engineering rigor while using natural language to express logic and requirements. This isn't theoretical, it's producing real business results for me, and unless I am engaging you in a client relationship where you specifically demanded transparency into my workflows as contingency towards a deal, then perhaps I would open up with more specifics.

The only other people to whom I open up specifics are others operating in the same paradigm as I am: colleagues in this new way of doing things. What exactly do I owe you? You're proven unable to non-emotionally judge ideas on their merits, and I bet if I showed you one of my codebases, you would look for the least code smell just to have something to tear down. "Do not cast your pearls before swine."

But here's what's interesting: you're demanding I prove a workflow that's already working for me, while defending traditional approaches based purely on... what exactly? You haven't demonstrated that your 'deep architectural insights from typing semicolons' produce better outcomes. So we'll have to take your word for it as well, huh?

The difference is I'm not trying to convince you to change your methods. You're welcome to keep doing things however you prefer. I'm optimizing for results, not consensus.

Big moat you have there I bet

module Obirunda where

import Control.Monad.State

import Control.Monad.Writer

import Data.Functor.Identity

type Argument = String

type Evidence = Maybe String

type Competence = Int

data ObirundaState = ObirundaState {

    arguments :: [Argument],
    evidence :: Evidence,
    competence :: Competence

} deriving (Show)

obirundaLoop :: StateT ObirundaState (Writer [String]) ()

obirundaLoop = do

    modify $ \s -> s { arguments = ["tradition", "syntax sacred"] }
    tell ["demanding proof from others"]
    modify $ \s -> s { evidence = Nothing }
    tell ["providing none myself"]
    obirundaLoop

runObirunda :: ObirundaState -> ((), [String])

runObirunda = runWriter . execStateT obirundaLoop

-- ghci> runObirunda (ObirundaState [] Nothing 0)

-- Never terminates. Pattern recognition, anyone?

Haha wow, you're so so funny. You may have shown too much already. Also, be careful, you might be too smart. You're cute though

Actually, it's a huge moat because the majority of the tech industry is like you, refusing to abandon your horseless carriage artistry for what is coming, and that is going to be natural language programming.

The issue is that the software industry as a whole has lost trust, larger society does not trust software to not have surveillance capitalistic aspects, and that is just the tip of the unethical nonsense that the software industry tried to pretend "there's nothing that can be done about it". Well, there is: abandonment of professionally published software because it cannot be trusted. Technologically, engineering-wise it will be a huge step back for the efficiency of software, but who the fuck cares when "efficient professional software" robs one blind?

The software industry is rapidly becoming an unethical shithole, and no uber productivity anything sells without trust.

Sorry to interrupt here, but handfuloflight, see: this is what I mean by "it's like talking into a void"., my first statement in what started this whole thread. obirunda is doing exactly what you say here: projected some fiction in their imagination, and they are arguing against that, and not your statements which appear to be ignored, or not understood. obirunda is listening to the fictional narrative and not what you're writing.