Software quality now depends on the constraints you set around your agents.
When humans manually wrote most of the code we could look at the code itself for signs of quality. Is it clean? Is it thoughtful? Is it fast? Can another engineer understand it? Does it have tests?
Agents can now generate more code than people can read. When code generation scales beyond review, quality - checks for one or more of correctness, maintainability, security, performance etc - increasingly has to live somewhere else.
It moves into the harness, environment and operating system around the agent.
This can be the tests and deterministic checks that decide what the system is allowed to do (amongst others). Your constraints are what may eventually enable loops of agents to deliver production software reliably. They can include unit tests, property tests, acceptance tests, mutation testing and quality metrics.
This back-pressure lets the system resist bad work before it becomes somebody elses problem.
Set your constraints. They decide whether the code your agents generate is good enough to ship.
i'm slowly realizing that the code i'm writing is no longer code
traditionally when we build software, we write code. code tells the machines "here's what you do"
if we write wrong code, machines will do wrong things. and that's what we call a bug
earlier this month, i wrote a pretty bad bug into one of firstmate's bash scripts. the code literally can't run, and should have broken firstmate
except it didn't. it went unnoticed for days. i discovered it when i came across the code and spent minutes wondering how on earth this could work
i then found that the agent ran the script, saw it fail, figured out what the script was trying to do, and did a workaround to achieve the same goal
so a bug that should have crashed the whole software almost didn't have any visible impact
that's when i discovered that what i wrote in the bash script is no longer code. it's not "here's what you do"
it's intent. it's "here's what i want"
intent doesn't crash and can't be broken. it gets executed regardless whether it's "correct" or not. i can no longer write "bugs"
what can still happen in intent is what i call "misses", which could be -
1. a misalignment between what's written and what my real intent is - this happens when i fail at articulating my thoughts
2. a misalignment between my real intent and the real demand - this happens when i fail at understanding the world
those are becoming the most important human skills in this new era
Initially we leaned heavily on engineering, having less confidence in the models themselves.
Our products started evolving much faster as that confidence grew (models too) and we shifted to letting AI try first and engineering around it only if it couldn’t.
2/2
Well written blog!
Working on AI engg for a year, have realized experience isn’t the only thing that gets taxed. The trust/confidence in it matters as well.
1/2
@samhogan This is nice! How do you eval multi-turn agentic call?
Say Opus 4.8 on a single response might call for the Read tool, while GLM 5.2 might call for the Edit tool.
Ideally we would want to compare the full agent sessions of both the models to evaluate their paths and results.
Came across this right now, though not released as part of #WWDC.
Interesting to see macOS have local model inference (with support to fine tune) straight out the box! 👀
https://t.co/HG1OFQ3QCB
@stevendcoffey@rBharshetty Can the agent sdk scale horizontally across pods or many machines? Claude Agent SDK had the nuance that their sessions/snapshot management were done through files and hence couldn’t scale across ephemeral pods.
Judging by my tl there is a growing gap in understanding of AI capability.
The first issue I think is around recency and tier of use. I think a lot of people tried the free tier of ChatGPT somewhere last year and allowed it to inform their views on AI a little too much. This is a group of reactions laughing at various quirks of the models, hallucinations, etc. Yes I also saw the viral videos of OpenAI's Advanced Voice mode fumbling simple queries like "should I drive or walk to the carwash". The thing is that these free and old/deprecated models don't reflect the capability in the latest round of state of the art agentic models of this year, especially OpenAI Codex and Claude Code.
But that brings me to the second issue. Even if people paid $200/month to use the state of the art models, a lot of the capabilities are relatively "peaky" in highly technical areas. Typical queries around search, writing, advice, etc. are *not* the domain that has made the most noticeable and dramatic strides in capability. Partly, this is due to the technical details of reinforcement learning and its use of verifiable rewards. But partly, it's also because these use cases are not sufficiently prioritized by the companies in their hillclimbing because they don't lead to as much $$$ value. The goldmines are elsewhere, and the focus comes along.
So that brings me to the second group of people, who *both* 1) pay for and use the state of the art frontier agentic models (OpenAI Codex / Claude Code) and 2) do so professionally in technical domains like programming, math and research. This group of people is subject to the highest amount of "AI Psychosis" because the recent improvements in these domains as of this year have been nothing short of staggering. When you hand a computer terminal to one of these models, you can now watch them melt programming problems that you'd normally expect to take days/weeks of work. It's this second group of people that assigns a much greater gravity to the capabilities, their slope, and various cyber-related repercussions.
TLDR the people in these two groups are speaking past each other. It really is simultaneously the case that OpenAI's free and I think slightly orphaned (?) "Advanced Voice Mode" will fumble the dumbest questions in your Instagram's reels and *at the same time*, OpenAI's highest-tier and paid Codex model will go off for 1 hour to coherently restructure an entire code base, or find and exploit vulnerabilities in computer systems. This part really works and has made dramatic strides because 2 properties: 1) these domains offer explicit reward functions that are verifiable meaning they are easily amenable to reinforcement learning training (e.g. unit tests passed yes or no, in contrast to writing, which is much harder to explicitly judge), but also 2) they are a lot more valuable in b2b settings, meaning that the biggest fraction of the team is focused on improving them. So here we are.
Great read on the current state of software engg.
> people who have the experience, expertise, competence, and the ability to articulate can use these (AI) tools to get the outcomes they desire with the right sets of trade-offs.
https://t.co/sz694BCogI