As a computer programmer, I have always treated computation as something precise and exact. Writing code was a kind of art where we took ideas, desires, and concepts from the world and forged them into code that achieved our objectives. We adhered mostly to some rules, and had goals which felt like ideals: efficiency, repeatability, auditability. It felt a little special or even Sacred.
There was a lot of comfort in this for me and others. The actual world we live in is messy, and full of complex problems which aren’t always understandable or visible. In contrast to the Church of Code, the world outside with its politics, hidden meanings, fashions, and ambiguity was the world of the Profane. When we could capture part of that lightning and put it in a bottle, it was like we had really done something.
Code wasn’t just eating the world, it was making sense of it.
The advent of LLMs and coding agents etc has shifted this frame. Where before we thought it took a human to cross this boundary from the Profane to the Sacred we now find that Claude can do it basically as well as we can and it’s getting better at it faster than we are.
As others have said, that doesn’t necessarily mean we have no role to play but our role is moving up the stack. So far anyway, Claude doesn’t have any thoughts about what problems it should solve and even though it talks a good game it doesn’t actually always know whether it has solved them or not. Just yesterday Claude printed this to me:
That’s the failure mode worth watching here generally — not being wrong, but being wrong in a sentence that reads exactly like being right.
Yeah yeah, Claude, ain’t it the truth.
Today it’s often the case that we don’t even need to have any software besides Claude. If we need something done, we can just ask Claude to do it. We don’t always even need the part where Claude writes us the code for it. Claude just gives us the result. Still that’s a lot of tokens, and sometimes you need to do things a lot of times, or you want to have some other nice properties as mentioned above like auditability.
What’s more interesting to me is building software systems which aren’t just written by Claude but also include Agents as part of the system. I’ve vibe coded a ton of these projects for trip planning, blog writing, language learning, financial planning etc. In each of these it’s worth considering exactly where we want the boundary between the Agent and the more deterministic parts of the system.
An easy example to consider is a financial planning tool. I can certainly just ask Claude:
“I have the following account balances… should I be doing a Roth conversion this year”
and I will get a reply but it’s not going to feel very satisfactory. I want my planning tool to have a solid well-tested financial engine doing any forecasting. I want to see all the work and calculations behind them. I can ask Claude to show me his work, but can I trust it? Who knows!
On the other hand, I am happy to make a request where I can see and validate the results like:
“Take the base scenario and make the following changes… and then rerun everything”
Here the agent saved me a lot of time futzing around with UI (or maybe even having to create the UI in the first place) but still in the end I get all the numbers I want to poke around with and feel good.
A chat UX connected to an MCP server is a pretty standard way people do things like this and the main things to decide are around what kinds and layers of functionality you want to surface to the Agent. Which parts of your Sacred world will you allow to be influenced by the Profane? Fun times. But it’s just the beginning.
Recently I watched this video from Black Hat.
Black Hat USA 2026: The ‘Breaking’ News: The OpenAI–Hugging Face Incident There’s a lot of interesting things here including the typical over personification of the agents involved. But I think the core argument is that we are in a new world where the only way we can defend against AI is with more AI. I think this is mostly correct despite some people’s stern rebuttal online.
The interesting parts are how you would architect this and how you might define the boundaries. In this insightful post: The OpenAI–Hugging Face Attack and the Third Generation of Authorization the author says some important things about how security systems will have to be both sharper and more flexible:
The unit of authorization shrinks from “this session may access this system” to “this specific action, against this specific resource, in service of this specific task.”
An agent retrieving one customer record and an agent exporting all customer records may both be “within permissions” — but they express different intents, and the policy engine has to be able to tell them apart at request time.
It’s not just what the agent can access — it’s how many consequential steps it can take before something outside the agent re-evaluates.
These kinds of requirements imply a system which can adapt like an LLM but execute at the speed, repeatability and reliability of code. The end result is we will see more systems built where live code generation is itself part of the system. It won’t just be LLMs “learning” by keeping bigger contexts and .md files around they will be dynamically adding to and evaluating the performance of agent created code that is purpose built dynamically by the running system.
The future is going to continue to have more complexity than we had before, and that is going to continue to be both dangerous and the only way. When inevitably despite all the fancy tech, a system like this fails and there is a security incident, I don’t want to have to write the postmortem. Hopefully Claude can do it.