Agentic Engineering Weekly for September 18-27, 2026

Jo Van Eyck

Jo Van Eyck

— 10 min read
Share
Agentic Engineering Weekly for September 18-27, 2026

The question moved this week. Nobody serious is still asking whether agents can write the code: the people shipping the most are asking who verifies it, how cheaply, and how to move humans on top of the loop instead of stuck inside it. Meanwhile two new frontier models dropped and DHH declared hand coding over to the rails community.

My top 3 picks this week

Autonomous verification is the ladder from in-the-loop to on-the-loop

If you watch one thing this week, make it Lauren "poteto" Tan's walkthrough of their software factory. It's the best 30 minutes you'll spend, and it mirrors my own agentic engineering process almost one to one. Poteto ships around 2,000 pull requests a month. What makes that possible is autonomous verification: the factory doesn't just produce code, it produces evidence that the code works. That evidence is what lets you climb from in the loop, approving every step, to on the loop, supervising a system that checks itself and only intervening at high-leverage points.

My own rule of thumb after two years of building software with agents: the quality bar for code that first meets human eyes should be extremely high. It's always worth spending extra tokens on higher-quality code and on evidence that's easier for human eyeballs to digest than reams of raw code diffs. Tokens are cheap and getting cheaper every quarter. Human attention is the scarcest resource in any software factory, so that's the thing to optimize for. Matt Pocock made much the same point on the AI Engineer Paris main stage, and the Claude Code team published a video on giving the agent more ways to check its own work so it needs fewer round trips with you.

From the other side of the court we have Dan Luu reminding us there's no point at which turning your brain off works: a Bazel migration still took months with agents because of the constant stream of decisions and unknown unknowns. And Simon Willison is increasingly convinced agents make software engineering harder, because unlocking them takes extraordinary discipline. Verification loops move the engineer to where the leverage is.

Worth reading:

The kernel of a coding agent is a while loop, and the KV cache is the real architecture

The team behind Jev, the "System One" decision model that came out of stealth last week, published their rough thinking on what a typesafe coding agent would look like. Their starting assumption is refreshingly blunt: coding agents are surprisingly simple. A while loop and a handful of tools. How would you design a coding agent if LLMs had no KV cache?

That question exposes a list of design choices we take for granted that only make sense because of cache economics. Take routing easy work from Opus to Sonnet and back: their napkin math puts pure Opus at roughly two thirds of the cost, because the big model has to re-read the whole context when control returns. Compaction assumes every future turn wants one shared state. Tool definitions eat the system prompt whether they're relevant or not. Subagents struggle less with the work than with deciding which context to hand over and which to merge back.

Their proposed direction: score every chunk of context for relevance per query (hide it, summarize it, or show it in full), load parts of AGENTS.md conditionally, and share explicit read-only state between background agents such as cross-model reviewers. Whether or not Jev is the vehicle, I find it a useful lens for anyone building a harness. The ecosystem around decision models is maturing fast: Sean Goedecke points out a general-purpose classifier can label the data to train its own narrow replacement.

Worth reading:

Nobody is caught up anymore: we each live in a our own private version of the future

Jessitron and Avdi opened the latest Machines of Code and Grace with a confession: nobody, themselves included, is ever fully caught up on the AI news cycle. I think that's a gross understatement for 99% of software engineers out there. Things move so fast that we are all living in our own private version of a possible future. Your team's idea of "how software gets built in 2026" is a fork, and so is mine, and neither of us has seen all other's.

You can see the forks everywhere. Less Bitter talked to 50 people 1:1 about how they code with AI and summarized the result in four words: it's a mess. Simon Willison quoted someone two weeks into a big-company job where the specs, code, tests, tickets and reports are all generated by Claude Code, and nobody on the team likes it. Sean Goedecke opens his advice for beginners by telling them to distrust engineers giving advice, because nobody really knows anything right now.

What's missing is the thing that normally syncs a community: shared norms, or as Jessitron puts it, "etiquette". Charity Majors and Cat Hicks started a dialogue on where AI norms even come from. One of lmy favorite conferences, XP Days Benelux, announced it won't return. One of the places where our craft used to compare notes is gone right when we need it most. Go find your people and compare notes people, I'll be doing exactly that at next month's Socrates BE unconference.

Worth reading:

The craftspeople are calling hand coding over, and the dissent is getting sharper

DHH gave the Ruby community its "hand coding is dead" moment at Rails World. His company 37signals has gone "pencils down" on handwritten code. DHH calls writing code by hand chiseling, and compares it to portrait painters when photography arrived: the good ones didn't stop making art, they moved on to other forms of creativity. Coming from the person who spent two decades defending programmer happiness and the joy of beautiful code, that lands differently than yet another founder tweet. Now, DHH and I disagree on a lot of things, but on this point we agree vehemently.

DHH isn't alone. Emily Bache wrote that a single year of AI overturned what 20 years of TDD practice had taught. Felienne Hermans told DDD Europe that AI made her doubt everything about programming. Angie Jones: we're system designers now. Tom Tunguz sums it up: AI removed the typing and left the system design.

The dissent is getting louder too. Alexandru Nedelcu argues that people who stop reading and writing code lose the wisdom that comes with it. Lars Faye points out agentic coding is barely a year old and the industry leaves no room for nuance. I'd frame it as a false dichotomy: keep the chisel as a tool you pick up deliberately to learn and to verify, but you have stop treating it as the default way you produce code.

Worth reading:

Opus 5.5 and GPT-6: stop telling the model to think harder, start telling it where the finish line is

Two frontier releases landed within an hour of each other: Anthropic's Claude Opus 5.5 and OpenAI's GPT-6 Sol and Luna. Prices halved again. Epoch AI puts the trend in context: the cost of a given level of AI performance falls about 13x per year, faster than electricity, compute or DNA sequencing ever did.

The more practical news is how your prompting should change. According to Anthropic's own guide, Opus 5.5 always thinks before replying, so your "think carefully" lines are dead weight. Hand it the complete task in one message with a clear finish line instead of drip-feeding guidance. Give your agents stop and continue rules upfront so long runs don't need your babysitting. Keep task lists out of the context window so they survive compaction. Ask it to mark explicitly what it couldn't confirm, and read the "needs from you" section first when a long run ends.

Reasoning effort is now a dial you set per task rather than a model you pick, which is exactly what Sebastian Raschka's deep dive on low, medium and high effort modes explains. One caveat from Simon Willison's testing: Opus 5.5 at "max" effort blew past the 128k output limit on some prompts. More thinking is not free, even when the reasoning tokens are cheap.

Worth reading:

At 50 deploys a day, the pull request is the next thing to go

Amp ships to production around 50 times a day with agents. Dario Hamidi credits their speed to letting go of pull requests rather than to AI, which Dario argues are holding most teams back. That fits a pattern we saw last week. Once agents write the change, every queue downstream of the diff becomes the bottleneck.

Linear's CI write-up shows what standing still costs. Their test suite nearly quadrupled since January. They switched to the native TypeScript compiler, moved to faster runners, doubled their test shards and consolidated seven checks into two, saving 87,000 runner-minutes per month. The payoff? PR wait time went from just over six minutes to just over five. That's the Red Queen effect surfacing in our deployment pipelines: running as fast as you can just to stay in the same place.

Worth reading:

The software factory is now a vendor category

A month ago a software factory was something you hand-built from blog posts. Today we have our pick between "build your own software factory" offerings. When vendors start packaging a pattern, the primitives are commoditizing: work queues, sandboxes, agentic identities, review loops, evidence packages.

That shifts where the value lies. There is no single best factory layout, and I'd be suspicious of any vendor claiming theirs is it. The winners will be teams that shape a factory to their own context, measure it and keep improving it. Steve Yegge's report from running around 50 agents on his game Wyvern is the useful counterweight to the demos: the breakdowns are as instructive as the breakthroughs. Matt Pocock warns that most companies aren't organizationally ready for background agents yet, however good the tooling gets. That was my exact closing quote during my last talk on software factories as well: it's obvious this is the direction where things are going, but none of my clients are ready for it just yet.

Worth reading:

Quick Hits

Read more