[camdenreslink]

The real best case scenario is using LLMs to help build deterministic systems. Instead of asking an LLM to do some task that you know will be repeated, instead ask the LLM to build a program (Python script or whatever) to do the task.

[dakiol]

If it's a one-off script/program that doesn't require additional "domain knowledge", sure. But what if you need to give as context your whole backend repository because you need to take into account a few business rules? Why give anthropic/openai access to my "secret sauce" (e.g., company private repos)?

In that case, it's way better to simply write the code yourself.

[mhss]

From all possible concerns, "giving access to anthropic/openai" to your "secret sauce" is the least important one for 99% of the companies out there.

No, is not way better to simply write the code yourself. Most of the code is written faster and better with Claude Code or equivalent. Very niche code is better written by hand. Even then, you're probably better off nudging something like Claude Code in the direction you need it to go. There's nothing interesting about writing it yourself unless you're still learning to code (in which case is a learning exercise for you, not only about the outcome).

[daishi55]

I promise OpenAI is not going to steal your “secret sauce”

[oblio]

Based on...?

[daishi55]

Your sauce is not worth stealing to OpenAI. They have bigger fish to fry

In fact - had there ever been a single case in the history of the internet where a service provider of any kind - hosting, storage, email, search, anything - has ever stolen intellectual property or trade secrets from a user and benefitted from it? Has that literally ever happened?

[jacobgold]

Making systems fully deterministic ignores the entire purpose of having agents involved.

IMHO the best of both worlds option is agents working with deterministic CLIs. Where the agent does the reasoning (and text generation) but uses CLIs to carry out all of the actions (issuing refunds, unblocking accounts, or whatever).

It's possible to get very reliable and consistent work out of agents when they're using well written prompts with well designed CLIs.

[variety8675]

Isn't this how we end up with things like: https://www.reuters.com/legal/government/high-profile-meta-a...

[jacobgold]

Yes: https://simonwillison.net/2025/Jun/16/the-lethal-trifecta/

Although you can certainly do a better-and-worse job of preventing these kinds of issues.

[camdenreslink]

I think it just depends on the workflow. A lot of times (probably the majority of the time) a well crafted deterministic process is what people want.

Sometimes you can have a multistep deterministic workflow with a decision that needs made somewhere in the middle, which is where an LLM that can call tools is useful.

I think there are much less repeated tasks where you would want a fully agentic process (but there are many ad hoc tasks where that is exactly what you want).

[bethekidyouwant]

How else would anyone do something like issue a refund if not through a programmatic interface?

[sqquima]

Direct access to the database, and create the "refund program" on the fly. Yes, stuff of nightmares.

[jcgrillo]

yes... ha ha ha... yes!

[bethekidyouwant]

Right thats just head cannon though. Unless of course you believe the lies you read on the Internet.

[jacobgold]

At some level everything an agent does is through a "programmatic interface" (tool calls).

Some people might use skill-based scripts, MCPs, or some kind of raw access to a database. My point is that well designed CLIs are the optimal programmatic interface, for many reasons.

[bethekidyouwant]

Sorry what other option is there? Is it going to create an API call from scratch every time after reading a page of documentation?

Wait raw access to the database? That’s one of the options for issuing a refund?

[cflewis]

Yes, it can do.

At Big Tech Company I Work At the LLM is quite happy to make raw API calls. If it thinks the data is big, then it'll write a Python tool to do it.

The reason crafted backing CLIs are useful is you can guide the LLM towards stuff that is immediately useful rather than hoping the nondetermism can separate the wheat from the chaff.

Take CI: is it interesting to know which tests passed? Maybe, but probably not. What is really interesting is what failed. Instead of having the LLM go out and talk directly to the CI system, write an intermediate CLI that filters out less actionable stuff by default, and have a flag that'll deliver the full dump if necessary.

It's a skill to do this stuff, and it's a lot of hard won experience than something I think is easily teachable. You kind of have to feel out your model and how it "thinks" about solving problems.

And then a new model version comes out and you have to learn it all again!

[kristiandupont]

>Making systems fully deterministic ignores the entire purpose of having agents involved.

That sounds backwards to me. I hope that most places don't see "having agents involved" as the ultimate purpose, but will use agents where it makes sense, i.e. when deterministic systems fall short.

[AlienRobot]

The best case scenario of LLM is transforming input into output where both are languages and accuracy doesn't matter, e.g. "rewrite this poem in pirate speech."

But that's not worth trillions of dollars...

[alexpotato]

100% this.

I've already commented on other posts that having LLMs build deterministic and testable tools is the real unlock.

Even for things like customer service, a LLM that analyzes customer support transcripts and then updates your call tree to better route people is a huge win.

[JCTheDenthog]

Or just write it yourself?

[whehhshs]

Because typing “code” takes time and significant amounts of it.

We are slowly waking up to the fact, which was always true, that “coding” is just a fanciful preparatory task in order to appease the spirits properly so that we may invoke the spirit of what we are actually after: a live, running process that does useful things. Code is completely useless when separated from that fact.

Typing it is a complete waste of time unless getting up close and personal with it will result in some kind of useful and actionable improvement in you or your understanding. Knowing when it does and when it does not have this property is a skill of its own.

[quacked]

> Typing it is a complete waste of time unless getting up close and personal with it will result in some kind of useful and actionable improvement in you or your understanding.

I believe this is the general belief about basically every human skill, that if you stop doing the technical fundamentals you get worse at understanding the activity. The question is whether coding is like sailing a square-rigged wooden ship, which became completely useless knowledge after the invention of the steam engine, or if it's like playing an instrument, which while technically unnecessary after the advent of MIDI and other tools, absolutely hurts your ability to arrange, compose and perform if the skill is neglected.

For my money: I think the AI scenario is more like the latter, but "humans are worse at coding" isn't the consequence I see coming. I worry that in ten years we will be awash in software that's impossible to understand. I don't think that's happened in any human industry ever. Someone has always understood how the machines are built, even if they're very remote from the users of the machine.

[taybin]

The sci-fi novel A Fire in the Deep starts with describing a Software Archeologist, who digs through millennia of strata of layers of indirection and I think we could end up needing that one day.

[saltcured]

Do they end up determining that every weird piece of code they find must have been used for religious or ritualistic purposes?

[AlexCoventry]

Ascension to AI plays a quasi-religious, soteriological role in the world of the book.

[inigyou]

No serious programmer is regularly bottlenecked by typing speed. Even the ones who type slowly.

If you find yourself writing repetitive code you should consider adding a layer of abstraction. If your language isn't powerful enough you can write a code generator.

[nik282000]

> Typing it is a complete waste of time unless getting up close and personal with it will result in some kind of useful and actionable improvement in you or your understanding.

Like, perhaps, understanding that it is free of security and functionality bugs.

[jcgrillo]

> a live, running process that does useful things

That is one of the things code does. It also communicates the developer's thoughts about how that process should work to others. If the latter is neglected, the code becomes very difficult to collaborate on. Very few lines of code that are written are "write once". Mostly they're changed, repeatedly, over time by many people. The live, running process is a very temporary entity by comparison. Yes, it needs to exist and do useful work. No, it is absolutely not the only thing that matters.

[krona]

The typing was never the bottleneck.

[satvikpendem]

Based on what I'm using AI for these days, seems like it always was.

[Philip-J-Fry]

It depends on where you're using AI. If you're working on a project for yourself or in a tiny company. Then sure, writing the code probably was your bottleneck. But at mid to large companies writing code is maybe 50% of the job, and the other 50% is the process around it. All those processes are the bottle neck, no matter how fast you can write the code. And this was a bottleneck I was hitting well before AI.

[Izkata]

I'd put it even lower than that, since there's also the "understand the problem space" portion outside of the external processes and before writing the code.

[bandrami]

So there are these things called "text editors"

[satvikpendem]

Hands don't type as fast as machines, no matter what editor you use.

[whehhshs]

Can you type a hundred lines a second? If not, then it is.

Code is obscenely low level.

[skydhash]

> Can you type a hundred lines a second? If not, then it is.

No one has ever needed to do that for something that is new. And if it’s not new, you want to do it repeatedly with some guarantee of reliability. Not just in an uncontrolled manner.

That is why we have snippet systems, macros and code generators. And the best with code is to solve problem once and reuse the solution. Which we have done with libraries, frameworks and supporting software.

[gloosx]

This is such a delusional take it's borderline trolling. Code is an expression tool to precisely describe a process that does useful thing. Typing prompts is not too different from writing some very vague code, which is arguably a waste of time by itself.

[wtetzner]

> Typing it is a complete waste of time unless getting up close and personal with it will result in some kind of useful and actionable improvement in you or your understanding.

I would argue that this is nearly always the case. I don't think people really understand programs that they've only read at more than a very superficial level. This is why I tend to make (temporary) small changes, printlns, etc. when exploring a new code base: it aids greatly in understanding how a program actually works.

And it's even worse (in my experience) with LLM generated code, as it tends not to result in particularly understandable code. It is a lot like LLM generated prose: it often looks entirely reasonable at a surface level, but has a of weirdness/incorrectness hidden beneath the surface. But that surface level makes it very hard to avoid glossing over the details when reviewing the code. For this reason, I personally find it's much more effort to carefully review code than it is to write it.

Humans make mistakes all the time, but their code tends to naturally be structured for human understanding (to some degree based on skill/experience) because they themselves needed to understand it to write it.

I think LLMs are very useful tools, but after quite a lot of experience using them, I think it's generally better to use them as a sounding board, or to help you get unstuck or remove points of friction. Using them to write all of your code (at least for me) seems like a net negative.

I also think it's extremely easy to overestimate how much time they save. It feels like they're a productivity boost because it takes less intense focus to implement something. But I've experienced several instances where actually writing the code myself would have been both quicker and have resulted in better code.

All that being said, it can also be really hard to not write all of your code with agents once you get used to it. There's also a kind of slot-machine-like effect where you write a prompt, excited for the result, and when it doesn't quite come out right, you think "ah just one more prompt and it'll be good." It's hard to see when you're actually doing it though.

It's also weird to me how much people think typing is what the LLM is replacing. Typing was never the hard part. It's the translation of the high-level idea into an unambiguous process that's hard. That's also the valuable part, that requires thinking through the edge cases and consequences of decisions, and that just gets glossed over when using an LLM unless you rigorously review what the LLM has done.

At the end of the day there's a real tradeoff to be made, and it's worth being conscious of what's being given up.

[dukeyukey]

If you already know what the inputs/outputs are, why should you spend days or weeks of your life typing it out rather than giving it in a well-specified and tested form to an LLM to get it done a hundred times faster?

[skydhash]

Because it’s rarely so black and white. Knowing the inputs and outputs is merely the first steps, you need to think about the transitions too as they have their own costs.

Those costs don’t disappear and it’s truly naive to think they don’t matter. Take security issues, they may arise because what you thinks was the input is merely a subset of the true input range. And the extra possibilities lead to unforeseen behavior.

A lot of programming is about ensuring that the input and the output are the sets defined in the specs. And the rest is that the transition/relation is the right tradeoffs of performance, correctness, and costs.

[xigoi]

The behavior of an LLM is not and cannot be “well-specified”.

[Der_Einzige]

trumps voice wrong

https://developers.openai.com/api/docs/guides/structured-out...

https://github.com/guidance-ai/guidance

https://github.com/noamgat/lm-format-enforcer

https://github.com/mlc-ai/xgrammar

https://github.com/dottxt-ai/outlines

[JCTheDenthog]

Libraries like Guidance guarantee that the output of an LLM will be syntactically correct (i.e. it will be valid JSON or whatever output format you are wanting). They do not, and fundamentally cannot guarantee that the data contained in them is actually correct, and cannot make the actual behavior of the LLM "well-specified". Or, as you put it, trumps voice wrong.

[dosisking]

Because the LLM version will have countless number of bugs and security holes, which means you will spend weeks or months of your life fixing them.

[chasd00]

This is a truth that many are having a hard time accepting. Getting shoved into the light so fast is blinding.

[anon7725]

We understand what you’re claiming, we just think that you are wrong.

[JCTheDenthog]

>rather than giving it in a well-specified and tested form

So, code?