Agentic Engineering Weekly for November 7–15, 2026

Jo Van Eyck

Jo Van Eyck

— 11 min read
Share
Agentic Engineering Weekly for November 7–15, 2026

Fable 5.2 dropped, AIE Code Summit wrote a manifesto against slop, and a model you're not allowed to use came back from the Linux kernel with 948 root exploits. Agents now write cleaner code than ever, but gladly slop up the place if you look away for a second. Gardens or factories?

My top 3 picks this week

AI Engineer Code Summit is by far this week's best source of alpha. A write-up of my personal highlights below.

Every team needs a gardener

The good news first: Agents write tidier code than they did a year ago. The bad news: the slop didn't disappear, it got promoted. The new LibraryUseBench shows that 73% to 100% of each model's solutions regenerate and duplicate stuff a provided library already does. Agents work around agent-generated libraries 40% of the time, against 27% for human-designed ones. Obsessing over quality and DevEx (or a more apt AgentEx) still matters, folks.

Slop has asymmetric economics. The cost of producing a thousand-line PR is approaching zero, while the cost of reviewing it stays constant. Lauren Tan (poteto) has the best answer I've seen: every team needs a gardener. Someone (or something) watches the stream of PRs, notices the third isRecord helper function this week, the lint suppressions creeping up like weeds. Every weed you pull becomes a lint rule so it can never grow back. Steve Yegge calls these weeds "heresies". Cloudflare industrialized this approach: On the Next Token podcast, Dillon walks through their PR review agent: durable agents fan out into superfan reviewers that each obsess over a single concern, guided by an "Engineering Codex" where every heuristic is written down.

Theo's gardening video added a twist I hadn't considered. Fast build and test loops are essential for a surprising reason: the KV cache. Slow feedback lets the prompt cache go cold, so every iteration gets slower and more expensive. Your ten-minute CI run is now a tax on your agents too. Same for software design, modular software is easier on the tokens.

Meanwhile, GitHub is turning into a slop highway, where the only way to keep up with agent-generated issues and PRs is to "slop back". Let's fight slop with some gentle gardening, not only with more slop.

Worth reading:

AIE Code Summit highlights

Two days, a lot of talks, and one surprisingly coherent message: verification is the foundation of autonomy, slop is the enemy, and the factory itself is becoming a commodity. The summit even produced a manifesto. "Slop is when we put less effort into producing something than we ask the consumer to spend understanding it." These are my favorite talks:

Lauren Tan (poteto), All Code Is Slop (Except Mine). 11,000 PRs in one month at a revert rate of around 0.5%. Agentic engineering is fundamentally an exercise in engineering trust: invest in the environment (architecture, types, lint rules, even TLA+ and Lean), make agents produce good code by default, then scale autonomy. Not the other way around.

Simon Willison, 2026 in LLMs. Another inflection point arrived: agents that independently pursue ambitious goals, for good or for evil. The paradox is that the work doesn't get easier, we just get faster. If you don't raise your ambitions, you either burn out or bore out.

Diogo Almeida (TypeSafe AI), I Love You So Jevving Much. The bitterest lesson in ML: doing the right task beats data, compute, or algorithms. The bigger opportunity isn't AI writing software faster, it's making software itself intelligent, with intelligence embedded invisibly instead of bolted on as yet another chatbot. Jev is the new NAND-gate primitive.

Steve Yegge, Software Factories: Escape from Trash Mountain. Coding is solved, orchestration nearly so, and the next bottleneck is users who don't want a constant deluge of features. Treat factories like organizations, beware of over-fencing, and build stuff rather than just factories that build stuff. Factories will become a commodity sooner than you think.

Armin Ronacher, The Software Atelier, Not the Software Factory. Another call to raise ambition, but explicitly towards higher-quality software (shout-out to Mitchell Hashimoto). Build an atelier, a workshop for craftsmanship, before you industrialize: push back on agents, preserve understanding, resist unnecessary complexity. "Now we can build everything, maybe we should not."

Quinn Slack (Amp), A Company Built Around the Agent. Agents don't just change how we build software, they change how companies are organized. The AI-native company is radically smaller, flatter and faster, with people working across traditional functional boundaries. "Get out of the cage." Had a strong but practical whiff of "organizational singularity".

Dex Horthy, 12-Factor Factories. Twelve heuristics, from "loops need forward and back pressure" to "fight slop systematically" and "use slop deliberately where appropriate". My favorite insight: human review is an optimization problem. Attention doesn't scale, spend it where it matters.

Zach Lloyd (Warp), From Software Engineering to Factory Engineering. A software factory is a "code-defined closed-loop system for continuously measuring and improving cloud coding agents". The real breakthrough is recursive process optimization: capture every session, evaluate outcomes, benchmark configurations on your own workloads.

Thariq Shihipar, The Sweet Side of the Bitter Lesson. Beautiful dualities: AI is both an industrial revolution and a renaissance, both a jagged frontier and a smooth interior. Design workflows around human understanding, so engineers keep a coherent mental model and creatives can stay in flow. "We can use intelligence to understand and shape how we use intelligence."

Brandon Thomas (ArtCraft), How to Open Source the World. The story behind the Photoshop-inspired, fully agent-operable open-source PhotoShop alternative. AI makes it economically viable to reclaim software from proprietary platforms, turning software you rent into software you own.

Worth reading:

The security hamster wheel is just getting started

OpenAI spent $1.2 million letting a model loose on the Linux kernel. It came back with 948 root exploits. Fireship calls it a bargain. I agree. Each new frontier model release resets the security baseline, each one just finds more exploits than the last. We're on a hamster wheel that's only starting to spin. On a personal related noted, my pantry is a bit fuller than a year ago and I have started carrying cash again.

The attacks are getting stranger too. Railway's post-mortem of its October 21st security incident reads like an episode of Cyberpunk: Edgerunners, except it's very real. The attacker stole a copy of the monorepo, ran agent fan-outs over it to find new ways in, and went after AI provider keys, which Railway believes were sold "to distributed transfer stations for use in distillation". We've heard this before from the OpenCode crew. We've seen this before with Hugging Face. My favorite line: "The escalating situation became a contest of agent speed, with Railway defending against abliterated models and a harness similar to ARTEX." About 100,000 workspaces were exposed and roughly $740,000 in stolen tokens got burned.

Finding vulnerabilities now scales infinitely, fixing them hasn't caught up yet.

Worth reading:

Congrats, you are now a manager

Addy Osmani makes a point that will make many IC's wince: if you spend all day with a coding agent, you are managing. You select tasks, write briefs, delegate, follow up, evaluate and decide what ships. Every gripe you have about bad managers is a bug report for interacting with agents. Vague handoffs, shifting expectations and missing context hurt agents exactly like they hurt people. The fixes are management 101, too: give agents a way to check their work, make every correction compound, delegate the task but never the judgment. Over-process is the new micromanagement. ALL-CAPS rules in your CLAUDE.md are the agentic equivalent of a manager who can't let go.

Which raises the question of how to measure where you are on your agentic engineering journey. Zach Wills published an update to the agentic engineering maturity ladder that I really like. Their seven levels are all framed by one single question: what are you still doing yourself? Hand it the ticket, make the codebase explain itself, let it prove its work, get it off your laptop, close the loop, make it multiplayer, decide what's next. Most teams stall at level four, moving the work off the laptop and into the cloud. This matches my own observations.

Russ Miles adds the necessary nuance. Reducing AI maturity to a single number is a limiting belief. He separates the habitat level, the highest level your environment safely supports, from the working level you choose per task. I hit on the same theme with my "LEAP" framework I disclosed in one of my earlier newsletters. Drawing on aviation's "children of the magenta", he suggests stepping down a level whenever you can't say what the agent is doing right now. One more thing I'm finding: an agent fills the feedback gap a lot of engineers experience, but not the belonging gap. It's a rubber duck that talks back, but it won't make you feel seen by your peers. That part of management will forever need humans.

Worth reading:

Stanford now teaches agentic engineering

What do you assign when students can finish last year's homework with one prompt? Stanford's CS146S, The Modern Software Developer, has an answer I love. The course covers MCP, agent skills, spec-driven development, loop engineering and the software factory. For its second run, Mihail Eric brought open-source maintainers into the classroom. Students have to understand an unfamiliar repo, propose a change and explain it to the person who will actually review it. That's the real job in 2026, compressed into a semester.

Notice what this does to the learning loop. Generating code is cheap, so the course grades the expensive part: comprehension, judgment and the ability to defend a change to a skeptical human. Mitchell Hashimoto calls this "the whiteboard test". If you're treading unfamiliar waters, use the AI as a mentor, not a coder. There's my LEAP again.

So here's my question: are educational institutions in your country following suit? Most curricula I see are still debating whether to allow AI tools at all, while Stanford is teaching students to run the whole darn factory. Companies aren't off the hook either. Ten engineers each finishing a Udemy course leaves Shu-level knowledge sitting in ten separate heads. An organization learns as a whole only when know-how is shared across people. Time to dust off your communities of practice, people.

Worth reading:

Fable 5.2: raise your ambition or panic?

Anthropic released Claude Fable 5.2. Fable went straight to first place on Artificial Analysis, built a working operating system with over 1,000 subagents running for days, and "solved two open problems in the physics of black holes". Google shipped Gemini 4 Carbon, its best Gemini yet (but that's not saying much on the Pareto-frontier). Elsewhere, the CEO of the company selling the shovels got ousted over an alleged GPU-smuggling romance. Just a normal week in AI now. The most level-headed take on what all this means: there's pretty much no limit left to what you can build. Raise your ambition.

The alarmist camp keeps growing as well. Dwarkesh moved from "at least a decade" to superintelligence by 2030 in three months. Rutger Bregman, from "De meeste mensen deugen" fame and a former doomer-skeptic, now argues against RSI. I believe the choice between ambition and alarm is a false one. Ethan Niser frames the personal version well: do you love the craft, or what it produces? If it's the latter, you adapt and don't try to hold back this ocean. Take the risks seriously, but build bigger than ever.

Worth reading:

MCP and WebMCP

Watching an agent click through a web page via screenshots is like watching someone type with oven mitts. WebMCP, an early W3C Community Group proposal, lets a page declare tools directly, with a name, a description, a JSON Schema and safety hints. With Claude in Chrome, the webMCP approach takes 4 browser actions and 0 screenshots, against 13 actions and 4 screenshots by computer-use and clicking. That's half the tokens and a few seconds faster on a to-do app. Imagine the difference on the real web.

The same idea is showing up on the backend. Naftiko argues you should put MCP next to your API, not on top of it, so agents get a capability surface designed specifically for them. David Cramer's answer to "MCP or CLI?" is simply "yes". The pattern is clear: the web is growing a second, agent-facing interface right next to the human one. Expect "agent experience" to become a design discipline in its own right. Just mind those safety hints: a consequential tool on a page is a new attack surface.

Worth reading:

Quick Hits

Read more