We are past the “is AI useful?” debate.

On April 7, Anthropic announced Claude Mythos Preview, a new frontier model they are not releasing to the public. They are holding it back because it finds software vulnerabilities too well. A 27-year-old bug in OpenBSD. Zero-days in every major browser and operating system. Mythos is being given to a small group of launch partners and nobody else.

Meanwhile Daniel Stenberg, the maintainer of curl, posted this a few days ago:

“I ran a quick git log grep just now. Over the last ~6 months or so, we have fixed over 200 bugs in curl found with AI tools.”

Stenberg used to be the loudest voice against AI-generated security reports. His position has shifted. The slop is basically gone. What is left is a flood of real reports. Curl has received more security reports in the first quarter of 2026 than in all of 2024, at four times the weekly volume. Maintainers across the ecosystem (Apache, Django, Firefox, git, glibc, the Linux kernel, Python, Wireshark) are drowning in legitimate AI-assisted work they cannot absorb fast enough.

And it is not only about security. Real software is shipping. Mitchell Hashimoto has been writing about his adoption journey at HashiCorp and on Ghostty:

Simon Willison has been writing consistently about patterns that actually work for professional engineers using agents:

They are building with it, in public, and documenting what is working and what is not.

Capable models are finding real bugs in critical infrastructure and real software is shipping. The ecosystem that has to absorb all of this is not moving at the same speed. That is the real tension in April 2026, and it is not going away.

I use Claude Code and Codex every day.

I don’t have a CMS for this website anymore. I ask Claude Code to publish things and it does. I wrote about that here.

I run every project at the level of automation that fits it. I think of it as three tiers.

I am the CEO, the agent is the developer. I never read the code. I describe what I want and use the thing. I have a personal journal app, a podcast listening app, and a handful of CLI tools in this tier. I have never looked at the source for any of them and I don’t plan to.

The point of this tier is that if the software is just for me and nobody gets hurt when it breaks, then the code is not the artifact. The artifact is the experience of using it. If the experience is good, the code is good enough.

Anything that ships to other people lives here. new.space is in this tier. My cofounder and I review everything carefully. Sometimes I write the code myself, especially in areas where the current generation of coding agents struggle. Sometimes I will have an agent do a spike, telling it to do whatever it takes to get it to work and giving it a verification loop (even if that means UI testing or simulation). After I see the spike working I throw all of that code away and start over. Then I work with an agent more closely to build a real version of the feature, with the spike as my reference.

This tier is the one people struggle to talk about honestly. You can move fast with an agent and you can also ship dangerous code fast with an agent. Both are true at the same time. The answer is process, not ideology.

For projects in this tier: I write near 90% of the code myself. Usually because I want to learn something, or I genuinely enjoy the problem, or both. I keep an agent open in another window and ask it questions as I work, like a coworker I can interrupt for free. Sometimes I will let it generate something tedious: fixture data, a batch of repetitive tests, a pattern I have already established that I don’t want to type a hundred more times.

The code is mine. The agent is a reference that can also type.

The thing that matters more than any single tier is letting each project live at the level of automation that fits it. A personal CLI does not need code review. A mobile app that handles other people’s data absolutely does. A side project where the goal is to learn should not be fully automated away.

If you are not using AI much yet, here is the minimum you need to understand what people mean when they say “agent.”

LLMs generate one token at a time

A large language model takes a pile of text (a “context”) and generates the next token. A token is roughly a word or part of a word. Then it takes the context plus that new token and generates the next one. And the next. It is doing statistics on enormous amounts of training data to guess what should come next.

That is the entire thing the model itself does. Predict the next token.

We can give the LLM tools

A “tool” is just a function the model is allowed to ask for. We tell the model, in its context, what tools exist and what their arguments look like. Some examples of tools:

• read a file at a given path
• write a file with some contents
• run a shell command and capture the output
• search the web
• query a database
• send an HTTP request
• take a screenshot of a running app
• run the test suite

When we give the model a list of tools, we are not giving it new abilities. We are giving it permission to ask for help. The model itself still only knows how to predict the next token. What has changed is that now some of the tokens it can predict are structured requests like “I want to call the run_tests tool with no arguments.” That request is just more text. Something outside the model has to actually run the test suite and then put the result back into the context for the model to see.

An agent is tools in a loop

An agent is a harness, a regular program, not magic, that does this in a loop:

1. Send the current context to the LLM
2. If the LLM writes a tool call, run the tool
3. Take the tool’s output and append it to the context
4. Go to 1

The harness is where the engineering happens. It decides which tools are available, how errors are handled, when to stop, how to keep the context from getting too big, what to log. Two agents running on the same model can feel completely different because their harnesses are different.

Verification loops are how agents get good

An agent writing code will be wrong a lot of times. A verification loop gives it a way to notice. Run the tests, check the types, compile, lint, take a screenshot of the running app. If something fails, the failure becomes part of the context. The next pass has new information to work with.

This is why TDD matters more now than ever. A test suite is a machine-readable spec that the agent can hit repeatedly. Without a verification loop, the agent is guessing. With one, it is iterating toward something correct.

Everything interesting that agents do today comes from this pattern: tools in a loop, checked by more tools.

Agents don’t get tired, don’t care if you throw away their work and start over, and so they can accomplish things that people normally wouldn’t. The more tedious, the more likely an agent is a good choice to handle it. A lot of the increased productivity people are seeing with agents right now is not doing their normal work faster, it is doing work they never would have even considered before because of the tedium or similar. This type of productivity increase is easy to overlook.

Not all AI is trained the same way.

There is a loud and correct argument that the big frontier models were trained on scraped content without permission. The courts are not going to unscramble this. The UK and Germany have already ruled in opposite directions on essentially the same question.

But “all AI is stolen” is wrong. There are models trained differently and they prove the ethical version is possible.

Adobe Firefly is trained only on content Adobe has licensed. Microsoft’s Phi-4 family is trained on a mix of filtered public data, licensed books, and academic sources, and it is small enough to run on a laptop or a phone. Allen AI’s Olmo publishes its weights, its training data, its training code, and its checkpoints. Their OlmoTrace tool lets you find verbatim matches between a model’s output and its training corpus. You can actually see where the words came from.

Provenance is possible. Provenance is a choice.

I don’t want to rent brainpower forever.

I am working on my own agent harness. I use Qwen 3.5 and Gemma 4 locally on my Mac today and both of them are genuinely good. The top local models right now are roughly where Sonnet 4 was a year ago, and I was using Claude Code with Sonnet 4 to one-shot and ship production code. That was enough then and it is enough now.

My goal for the end of this year is a local-first coding agent that can do 80 to 90 percent of what I need day to day. On my machine. No subscription. No network required for the work I care about.

The point is not ideology. The point is control. AI is moving faster than any regulator, any court, any maintainer, and any company’s ability to contain it. The answer is not to hide from it and it is not to hand everything to a handful of cloud providers. The answer is to own the tools we depend on, run them ourselves when we can, review them when we can’t, and be honest about which projects deserve which amount of care.

That is the current state of AI, as I see it, in April 2026.