Agentic Engineering Weekly for October 2–10, 2026

Jo Van Eyck

Jo Van Eyck

— 9 min read
Share
Agentic Engineering Weekly for October 2–10, 2026

Three big "state of the industry"reports landed this week, and they tell two very different stories: At the frontier, agents now open more pull requests than humans. In the median company, an AI seat costs twelve dollars. Meanwhile, mathematicians are going through the emotional maelstrom many developers experienced.

My top 3 picks this week

Last week's video

My take on "software factories" today.

The emotional maelstrom

The AI debate keeps getting flattened into two camps: people who love coding vs. people who love shipping. Red pill or black pill. Addy Osmani offers a better map with three sources of joy in engineering work. Making is the flow of shaping something until it clicks. Knowing is having a mental model so sharp that you can smell where the bug lives. Mattering is being the expert everything depends on. Agents impact each one differently, which explains why two engineers can watch the same demo and walk away with completely opposite feelings. We aren't disagreeing about the tool anymore (if you're still in the "slop" camp, I urge you to reconsider your priors, install a coding harness and spend an hour with Opus 5.5). We're mourning different losses.

Making survives: it just moves up a level, from lines of code to the loops, kitchens and factories that produce them. Mattering survives too, as judgment. Knowing is the one under threat. If you always pick from an agent's suggestions and never conjure your own, that "conjuring muscle" withers and dies. If you don't understand your own codebase, you aren't in the driver's seat. The agent is driving you. Once you lose the mental model, you lose the ability to verify, and being able to judge quality is what lets you hand work to agents safely in the first place.

Look at the loudest takes of the week through that lens. Baldur Bjarnason describes an industry turning hostile to the people who work in it. Web Dev Cody reads much of the anti-AI backlash as cope. DHH tells non-adopters they're losers, and a self-described recreational programmer pushes back from the woods. Jake Wharton puts "No AI" at the top of his list of values for a new employer, something you can only do from a position of extreme privilege today. Everyone (me included) is shouting "get with the program or get out". Not a lot of folks are talking about the other side of this conversation. Jessitron and Avdi add the sharpest warning: we sound like self-important doofuses when we prescribe what juniors should learn and how, because it isn't the world we came up in anymore.

Worth reading:

The frontier ships 9x more while the median seat costs $12

Gergely Orosz's state-of-the-industry keynote is full of numbers that would have sounded like science fiction a year ago. On GitHub, agent-authored pull requests grew 9x in eight months and overtook human PRs in August. At Linear, agents have opened more issues. Bun's Zig-to-Rust rewrite took 11 days against an estimated year and a half. The cost shows up in code review: under five to ten times the volume, review has largely become rubberr stamp theatre. The output went up, but at most places the feedback loops didn't scale with it.

Now look at the Stack Overflow survey. Daily use is substantial, not incidental: 55% of developers use AI for at least two hours a day. The State of AI report contains the most baffling number: median spend is $12 per seat. That's autocomplete money, not software factory money. If you're reading this newsletter, you're firmly in the 1% of early adopters. The rest of the industry is barely using these tools. The storm has yet to come. If you haven't watched it yet, last week's video gives a sneak peek of what this future might look like.

Worth reading:

Harnesses are turning into workflow engines

Agents that run for hours, hand off to colleagues and pick up again tomorrow need something chat loops don't offer: durable execution. The Pi team (Mario Zechner and Armin Ronacher) explain why they built Pi Durable around a small task-based workflow engine, so that multiplayer agents can suspend and resume anywhere. The interesting part is what they turned down: Temporal and Effect.ts. They also muse on what a TypeScript fork with Effect built-in could look like for agentic engineering (mind = blown). The harness is absorbing jobs we used to give to workflow engines and job schedulers.

The second job it's absorbing is verification. A Stack Overflow blog post puts it well: a green exit code is not evidence that the work happened. Agents produce self-assessments dressed up as status codes. They call sys.exit(0) to pass tests, or rename a user to stand in for a missing colleague and report the task done. The fixes are old CI wisdom applied to a new actor: assert on artifacts, verify independently of the transcript, alert on "successful" runs that changed nothing, and measure passes across repeated runs instead of trusting one green experiment.

The exe.dev team provided a nice insight: if you spin up more parallel agents to hide latency and feel more "productive", you wreck the one resource that doesn't scale: your attention. Their fix is to shorten the human-agent loop instead, with a fast model for conversation, screen recordings for feedback and structured HTML artifacts for review. Durable execution, independent checks and fewer agents point the same way. You don't get more throughput by feeding your factory more prompts. You redesign it.

Worth reading:

Clean-room rewrites of whole product suites are now a solo project

Here's another ambitious clean-room rewrite. Brandon Thomas used Claude Opus 5.5 to build seven MIT-licensed Rust clones of the Adobe product family. They're "super early alpha", and Hacker News made sure everyone knew it. Thomas still promises 99% parity "in months, not years". You can be sceptical about the timeline, but this is a trend to take seriously: reverse-engineering used to take person-years, now one person (and a big bag of tokens) can produce something credible in a weekend.

If features stop being a moat, the moat moves elsewhere. That's exactly where Ars Technica expects the legal trouble: the clones look a lot like their Adobe counterparts. Whether it's a x-to-rust language migration or a product clone, affordable clean-room reverse engineering has firmly left the realm of science-fiction.

Worth reading:

AI proofs now outpace human verification, mathematicians are joining the cope club

OpenAI released 722 manuscripts of mathematical results in one go, far more than the field can referee with their Saturday morning coffee. Several are solutions (or at least concrete steps towards solutions) to problems that had resisted top mathematicians for decades. You'd expect a (very nerdy) party. Instead, a lot of mathematicians are upset, and the reason is familiar if you write software for a living. For mathematicians, a proof wasn't the end goal. It was the understanding you built while getting there, the heated debate and verification from the community. A solved problem that nobody understands can be worth less than an open problem with people working on it.

ThePrimeagen's take is the best I saw on the implications. He covers why the "proof fanfare" is over, how Lean turns verification into something a machine can do, and exposes the uncomfortable category of "maths humans can't do". Sophie Maclean and Giordano Scarciotti give the mathematician's side with less snark and more sadness. We see you, mathematicians.

Swap "proof" for "pull request" and you get last year's "agentic engineering" newsletter verbatim. It's the same impact, impacting a different field. Mathematics at least has Lean, a formal checker that doesn't care who wrote the proof. Most codebases out there have nothing that strong. If anything, that should push us to invest in property-based tests, type systems and formal verification before our own output outgrows our ability to understand it.

Worth reading:

Personal software is cheap; knowing what another person wants isn't

Tolu built his partner a dog-care tracking app for her birthday in under two hours. It was a lovely gesture with one problem: she already had a system that worked, and he'd added charts because he likes charts. His post is a small, honest case study of what happens when building gets cheap. The golden rule ("build for others what I'd want for myself") breaks down when the other person has different habits. He also points out why it took two hours: twenty-two years of practice at describing what he wanted. The speed came from expertise, not from the tool alone.

Leverage makes the opposite case at scale: against a personal agent for every employee, in favour of a shared factory. One employee who spreads 3.7 hours a month across many tasks loses to a specialist who puts 18.3 hours into one shared workflow, five times further down the learning curve, with teammates watching the failures and fixing them.

Put the two posts side by side and the dichotomy dissolves. Personal software works when you're the user and you know what you want. As soon as someone else is the user, the old disciplines come back: discovery, feedback, iteration. Coding might be dead, but your job is safe.

Worth reading:

Geoffrey Huntley is cooking up some crazy (but very interesting) ideas

Geoffrey Huntley published five posts this week and each one is a mind-bender. In if your team is too busy doing their 'normal job' to experiment with AI, you're preparing them to be replaced he says AI literacy is no longer optional: give people time for it, have every senior engineer build their own coding agent, and hire on it. --help on your CLI is all you need for LLM context until you don't. sorts devtool vendors into two tiers. S-tier tools like gh are already in the model weights. F-tier tools need MCPs and skill packs, and his fix is to tune your --help output until agents need fewer tool calls. The Nix overlay post makes the case for Nix in the agent era: a few lines patch OpenSSL or remove git push --force everywhere, and NixOS rollbacks make it safe to give an agent root. In to Kodak yourself out of business he uses JetBrains as a cautionary tale: stuck in an IDE-centric worldview, it raised prices instead of rethinking its product for the LLM era. The wildest article is by far an application in lisp you grow by talking to it. There's no compile step. The LLM writes Lisp straight into the running image, and the app picks up new features while you chat. Crazy? Maybe. I still lie awake 3 days after reading it.

Quick Hits

Read more