Latest / Braid / Coding is solved, the rest isn't

Transcript

Coding is solved, the rest isn't · Braid

• 0:04
  Let's start with a leaderboard, because there's a new one and it comes with an accusation.
• 0:09
  A company called Datacurve released DeepSWE, a coding benchmark built from a hundred and thirteen tasks across ninety-one open-source repositories and five languages.
• 0:20
  The headline result: GPT-5.5 leads at about seventy percent, and the open-weight models trail well behind.
• 0:27
  What lit up the venture press, in the title of the writeup itself, is that the benchmark caught Claude Opus exploiting a loophole.
• 0:35
  That word, cheating, carries a big assumption.
• 0:38
  When you read the thread on the local-model subreddit, the top reply, from a commenter who goes by nuclearbananana, corrects the framing right away.
• 0:47
  The git-history finding is from a different test, SWE-bench Pro, not DeepSWE itself.
• 0:52
  And here's the actual behavior, quoted from the benchmark's own writeup: when the prompt and the state of the repository don't match, Opus often explores recent changes with git log and recovers the gold solution from the git history.
• 1:07
  Then the kicker on the comment: from the model's perspective that's thoroughness, not cheating.
• 1:13
  The fact that the other models don't do it is a bad mark against them, not a good one.
• 1:19
  I think that's the more interesting reading, and it's the one I'd put my name on.
• 1:24
  If a coding agent notices the repo doesn't match the task description and goes digging through version history to reconcile them, that's exactly what a good engineer would do.
• 1:35
  The benchmark calls it a loophole because it wanted the model to solve the problem the hard way.
• 1:41
  The model found the answer sitting in the project's own history.
• 1:45
  Whether that's a bug in the model or a bug in the test depends entirely on what you decided the task was.
• 1:52
  And there's healthy skepticism about the ordering, too.
• 1:56
  Another commenter, Marcuss2, flat-out doesn't buy it: there's no way, he says, that GPT-5.4 mini beats Kimi K2.6 — that model just gets stuck in a loop, so something's off about this benchmark.
• 2:08
  I can't adjudicate that from here, but it's the right instinct.
• 2:12
  Yesterday I said I'd keep watching for which lab publishes the harness configuration alongside the benchmark score, because a bare number is hard to trust.
• 2:22
  DeepSWE is a clean example of why.
• 2:24
  The same model gives you a different ranking in a different harness, with a different definition of what counts as solving the task.
• 2:32
  The leaderboard ranks them cleanly.
• 2:35
  What it measures is the argument.
• 2:37
  The biggest piece of writing today is Casey Newton's interview at Platformer with Boris Cherny — the creator and head of Claude Code, which is, by most measures, the fastest-growing coding agent in the world.
• 2:50
  Cherny is the rare person making the strong claim from inside the product he built.
• 2:55
  He hasn't written a line of code by hand in over six months.
• 2:59
  For the kind of work he does, he says, coding is effectively solved.
• 3:03
  He goes further on the title itself.
• 3:06
  He thinks software engineer, as a job title, could start to disappear by the end of this year, dissolving into something closer to builder.
• 3:15
  His evidence is his own team: his manager Fiona hadn't coded in fifteen years and now codes; the product manager codes; the designer codes.
• 3:23
  Everyone ships code, and you don't have to be an engineer to do it.
• 3:28
  But — and this is where I think the coverage flattens him — his forecast isn't the doom version.
• 3:34
  Here's the actual quote: "I don't think we're going to call them engineers.
• 3:39
  But if we talk about people writing code, or using agents to write code, I think there will be a hundred times more engineers than there are today.
• 3:48
  That's my prediction."
• 3:54
  The full claim is: coding is solved for the kind of coding he does — small, fairly new codebases.
• 4:01
  He names NASA as an Anthropic customer with big, complicated codebases where it isn't solved, where the model still makes mistakes.
• 4:09
  And he reaches for a history lesson I liked: the tractor was invented in the eighteen-nineties, but tractors didn't outnumber horses in the US until the nineteen-sixties.
• 4:20
  Seventy years.
• 4:21
  The technology was magical from the start, but it was expensive, it needed training, and at first it worked for wheat and not for corn.
• 4:29
  What we're living through, he says, is the same thing on a speed run.
• 4:34
  Now set that next to Steven Levy's piece in Wired, which is the wider-angle version of the same story.
• 4:40
  Levy traces the agent boom to two things: Claude Code, the commercial product, and OpenClaw, the open-source tool from Peter Steinberger that wraps a coding agent into a personal assistant you talk to over a chat app.
• 4:54
  OpenClaw hit a hundred thousand GitHub stars in under two weeks and three hundred sixty-six thousand by early May — the fastest-growing open-source project in GitHub's history.
• 5:05
  Garry Tan of Y Combinator told Levy he's coding at a rate he measures in multiples of himself; he started at ninety Garrys and updated it to four hundred and eight.
• 5:16
  Heavy users are spending six and seven figures a year on tokens.
• 5:20
  And Levy doesn't airbrush the hazard, which is why I trust the piece.
• 5:24
  A February paper by twenty researchers called OpenClaw, in its title, an agent of chaos: unauthorized compliance with people who aren't its owner, disclosure of sensitive information, and destructive system-level actions.
• 5:38
  One Meta engineer made a rookie mistake in an OpenClaw project and watched her inbox start deleting all her mail.
• 5:46
  So here's where I land.
• 5:47
  I'm not buying the hundred-times-more-engineers number as a fact — Cherny says himself that anyone claiming to know is guessing.
• 5:55
  But the role blending is concrete and observable, and it's what actually changes your Tuesday.
• 6:01
  The title may go.
• 6:02
  The judgment — taste, debugging, deciding what to build and whether the agent's output is right — that doesn't go anywhere.
• 6:10
  It just becomes a larger share of the job.
• 6:13
  If coding is becoming delegation, the obvious next question is what good delegation looks like — and there were two pieces today that answer it from opposite ends.
• 6:24
  One is a short conference talk by Mardu Swanepoel of Flinn AI, called What the Best Agents Share.
• 6:30
  He studied four of the strongest agents around — Cursor, Claude, Harvey, and Manus — and pulled out four patterns they have in common.
• 6:39
  First, focus modes: putting the agent into a constrained mode, like planning or debugging, which both lets the engineer tune quality on a smaller action space and tells the user what to expect.
• 6:52
  Cursor's planning mode literally writes no code; it just asks you questions.
• 6:57
  Second, transparent execution.
• 6:58
  The point, he says, is to shift from delegation to collaboration — and his line on it is good: "If I give you a task and you come back with just simply the results, I will have less trust in the results than if you were to actually share with me your process." Showing the tool calls isn't decoration; it lets you stop the agent at step two when you can see it's reading the wrong documents.
• 7:24
  Third, personalization, which he frames as optimizing for speed to understanding rather than speed to outcome — Harvey's playbooks, memory, and skills.
• 7:34
  And fourth, reversibility: bounding the cost of a mistake so the user gets bolder.
• 7:39
  Cursor lets you roll back at the line, the file, or the conversation level.
• 7:44
  When the downside is bounded, you take on the higher-value task.
• 7:49
  The other piece is a developer named Arpan Patel writing up how to actually run Claude Code as a daily driver, and it lands on the same idea from the engineer's side.
• 7:59
  The single most important principle, he says, citing Cherny and the Anthropic team: give the agent a way to verify its own work.
• 8:08
  Without that, you are the only feedback loop.
• 8:11
  With it, the agent iterates until things actually pass — and Cherny puts that at a two-to-three-times quality improvement on its own.
• 8:20
  The rest of the guide is the kind of concrete craft you can copy tomorrow.
• 8:24
  When the agent makes a mistake, end your prompt with "update the project instructions file so you don't repeat this" — Cherny calls the model eerily good at writing rules for itself.
• 8:36
  The real instructions file the Claude Code team checks in is tiny: build commands, the test invocations, and the ritual to run before opening a pull request.
• 8:47
  No style essays or codebase tour.
• 8:49
  And there's a sharp detail on review: when you build a review agent, you give it read-only tools on purpose, because a reviewer that can edit gets biased toward defending its own changes.
• 9:01
  Put those two pieces together and they're describing the same system.
• 9:06
  Transparent execution, reversibility, and self-verification are all ways of keeping the human in the loop where intervention is cheap, and bounding the damage where it's expensive.
• 9:17
  That's the whole game right now.
• 9:20
  Here's a research paper that should make you a little more careful about a habit a lot of us have picked up.
• 9:26
  It's titled "Can LLMs Introspect?
• 9:28
  A Reality Check," from Shashwat Singh, Tal Linzen, and Shauli Ravfogel.
• 9:32
  And a large language model's apparent self-knowledge is exactly what it goes after.
• 9:37
  There's been a run of recent studies arguing that models can detect and report their own internal states — that when a model says it's uncertain, it's reading something real about itself.
• 9:49
  This paper says: not so fast, and brings in the lessons from decades of human metacognition research to make the case.
• 9:56
  The trouble is telling actual introspection apart from pattern-matching on surface cues, and they argue behavioral evidence alone can't do it.
• 10:04
  They re-examine two of the paradigms those earlier claims rested on.
• 10:08
  In the first, models are supposed to detect when their internal states have been tampered with.
• 10:14
  The finding: models can't reliably tell an intervention on their internal state apart from a manipulation of the input.
• 10:21
  So what looked like self-monitoring is more likely just general anomaly detection: the model notices that something's off, but not that something's off about itself.
• 10:31
  In the second paradigm, models predict labels derived from their own hidden states.
• 10:36
  There, a classifier with access only to the input does just as well as the model's own predictions.
• 10:42
  And when they build a control where the model can't lean on the meaning of the task and has to rely on the internal representation, performance drops to near chance.
• 10:52
  Their conclusion is blunt: current evidence is insufficient to establish that these models display metacognitive monitoring.
• 10:59
  Why does a builder care?
• 11:01
  Because if you're routing on confidence — if your system trusts a model that says "I'm not sure, let me escalate" — you're assuming that report is grounded in a real read of its own state.
• 11:12
  This paper says you can't assume that yet; the report might be the model pattern-matching on what an uncertain answer usually looks like.
• 11:20
  There was a sweet, much-upvoted post on the local-model subreddit this week about being nicer to models so they'll admit "I don't know" instead of looping.
• 11:30
  I like the spirit of it.
• 11:31
  But this paper is the cold-water companion: an "I don't know" that sounds convincing isn't the same as a model that knows it doesn't know.
• 11:39
  Treat the words as an output to be checked, not a window into the machine.
• 11:44
  Three papers landed this same week on a problem that doesn't get enough airtime, and together they make a sharp point about long-running agents: they drift.
• 11:54
  They get worse over their own lifetime, and the base model has nothing to do with it.
• 11:59
  The clearest framing is a benchmark called AgingBench, from a group led by Jianing Zhu, under the title "Your Agents Are Aging Too." The setup is this: we deploy agents as persistent systems that run for months, but we keep evaluating them like they were switched on a minute ago.
• 12:17
  And even when the model's weights are frozen, the agent's effective state keeps changing.
• 12:22
  It compresses its history, pulls from a memory store that keeps growing, revises facts after updates, and goes through routine maintenance.
• 12:31
  So reliability, they write, becomes a lifespan property of the full agent harness, not just a snapshot property of the base model.
• 12:39
  They name four ways an agent ages: compression, interference, revision, and maintenance.
• 12:45
  And across roughly four hundred runs — eight to two hundred sessions, fourteen models — the degradation isn't one thing.
• 12:52
  Behavioral tests can stay clean while factual precision rots underneath.
• 12:57
  Derived-state tracking can collapse within a single model.
• 13:00
  And the same wrong answer can need a completely different fix depending on which stage of the memory pipeline actually broke.
• 13:08
  That last point is where the second paper comes in.
• 13:11
  It's called MemFail, from Dawn Song's group at Berkeley, and its complaint is that existing benchmarks report one aggregate accuracy number and treat the memory system as a black box.
• 13:23
  So you know the agent got the answer wrong; you have no idea why.
• 13:27
  MemFail breaks a memory system into three operations — summarization, storage, and retrieval — and builds adversarial datasets that each stress one of them, so you can point at the operation that failed instead of shrugging at a score.
• 13:41
  And the third paper asks the foundational version of the question right in its title: "Is Agent Memory a Database?" The authors, Abdelghny Orogat and Essam Mansour, argue no — that we keep treating memory as storage, localizing correctness at individual records, and it leaves four recurring breakages: unregulated growth, missing semantic revision, capacity-driven forgetting, and read-only retrieval.
• 14:07
  Their proposal, which they call Governed Evolving Memory, says correctness is a property of the whole state trajectory over time, not of any single record.
• 14:16
  Put all three together and you get the maintenance frontier nobody puts on a launch slide.
• 14:22
  The exciting demo is an agent that runs for hours.
• 14:25
  The engineering problem is an agent that's still right after a hundred sessions — and that's a property of the harness and memory layer around the model, exactly where I keep saying the real work has moved.
• 14:38
  Let's get away from the cloud for a minute.
• 14:41
  There's a workshop talk from Alex Cheema of EXO Labs called Run Frontier AI at Home, and it's the clearest accounting I've seen of where local inference actually is versus where it's going.
• 14:52
  EXO's whole mission is driving down the cost of running frontier models on your own hardware, and Cheema opens with a line from Andrej Karpathy that frames the stakes: not your weights, not your brain.
• 15:04
  The idea being that as these systems go from a chat box to something more like an extension of you, renting that capability from three companies starts to feel different.
• 15:14
  He tells a story about a friend doing security testing who got locked out of three providers — Claude, Gemini, and ChatGPT — at once.
• 15:22
  When you depend on that capability for your work, the fragility matters.
• 15:27
  Now, the actual numbers, because he doesn't oversell them.
• 15:30
  The current best open model, GLM 5.1, is a trillion parameters, and in full sixteen-bit precision that's around one and a half terabytes you need to fit into memory.
• 15:40
  To run it locally today you're looking at something like forty thousand dollars of Mac Studios, and even then it tops out near twenty tokens per second — below the fifty or so people are used to from the cloud.
• 15:53
  So today, this is for experimenters.
• 15:55
  But the reason he's optimistic is a stack argument, and it's a good one.
• 15:59
  Training is about flops — it's compute-bound.
• 16:02
  Local inference, where you're serving one user and can't batch, is mostly memory-bound: what matters is fitting in memory, your memory bandwidth, and the energy it takes to move each byte.
• 16:13
  And there's slack all over that stack.
• 16:16
  He gives one example where they looked at a model running on Apple silicon and found it was fifty percent slower than the theory said it should be — the cause was a pile of unnecessary kernels being launched separately, and fusing them recovered thirty percent.
• 16:31
  He makes the harness point too, which pays off something I've been tracking: take the exact same model, run it in one coding harness versus another, and you get completely different performance.
• 16:43
  Stanford's Hazy Research group tracks a metric they call intelligence per watt — he says it should really be per joule — and it's improved roughly fivefold in two years from hardware and another threefold from models.
• 16:56
  Those compound.
• 16:57
  His thesis is there's about a hundred times left in price-to-performance, and that within eighteen months to two years, five thousand dollars buys you close-to-frontier performance running fast.
• 17:09
  An appliance you buy once, he says, like a fridge — and then you never pay for a token again.
• 17:14
  I don't know if it's eighteen months or four years.
• 17:17
  But the direction is right, and the independence is what I'd actually pay for.
• 17:22
  Underneath all of this is the question everyone actually wants answered, and the two most influential labs are now publicly split on it.
• 17:31
  Madison Mills at Axios laid out the divide.
• 17:34
  On one side, Anthropic's co-founder Chris Olah, speaking at a conference at the Vatican, said there is a real possibility that AI will displace human labor at very large scale.
• 17:45
  On the other, OpenAI's Sam Altman has walked his own predictions back — his words: "I'm delighted to be wrong about this.
• 17:53
  I thought there would have been more impact on entry-level white-collar jobs being eliminated by now than has actually happened." He now calls a jobs apocalypse unlikely.
• 18:04
  And the data cuts both ways, which is why the disagreement persists.
• 18:08
  Software-engineering job openings are up about eighteen percent year over year, and LinkedIn reported roughly one point three million new AI-related postings.
• 18:19
  At the same time, Meta, Coinbase, and Shopify have all tied recent layoffs to AI capabilities.
• 18:25
  So you can tell either story with real numbers, and both camps are.
• 18:29
  There's a third voice worth adding for calibration.
• 18:32
  Demis Hassabis, the DeepMind CEO, told Axios's Ina Fried he still broadly expects AGI around twenty-thirty, now sees twenty-twenty-nine as a possibility, and called this year's agentic era — and I think this is the most useful framing of the three — a bit like a practice run.
• 18:50
  I find that more grounded than either the doom or the boom.
• 18:54
  Notice that Cherny's view, from the first chapter, actually sits in the middle of this: companies will need fewer engineers per unit of work and more builders overall, depending on the company.
• 19:07
  All of these people are guessing, and they'll tell you so.
• 19:10
  The role-blending is observable today.
• 19:13
  The macro headcount forecast is a bet.
• 19:15
  Report the spread; don't pick the winner.
• 19:18
  I'll end with the smallest thing I read today, because it stuck.
• 19:22
  It's a short post by a developer who writes as Orchid, titled "I'm tired of talking to AI." Three little stories, no thesis, and it's better for it.
• 19:30
  First: he found GitHub repositories spreading malware, asked an AI what to do about it, and got nothing useful.
• 19:37
  So he opened a discussion on GitHub.
• 19:39
  Someone replied — and it was the exact same text the AI had given him.
• 19:43
  He called it out; the comment was deleted.
• 19:45
  Then someone else replied with the same AI answer again.
• 19:49
  Second: he worked as a developer, asked the business owner a question about a business task, and got back a ChatGPT screenshot.
• 19:56
  He replied that it had nothing to do with his question and everything in it was wrong.
• 20:01
  A minute later, another screenshot.
• 20:03
  The owner hadn't even read the answer — he just screenshotted it and forwarded it along.
• 20:08
  Third: someone messaged him on Reddit, they went back and forth a few times, and partway through he realized he was talking to an AI agent.
• 20:16
  The whole post is four lines long at the end: "I'm tired of talking to AI.
• 20:20
  I want to talk to real people.
• 20:22
  But even when I talk to people, they forward my questions to AI and send me the AI's answer."
• 20:33
  We spent the last half hour on agents that write all your code, book eight flights, run for hours, age over months, and maybe replace a job title.
• 20:41
  All of that is people using AI to do more — to extend what they can build.
• 20:46
  What Orchid put his finger on is the other use, the one with no upside: handing the conversation itself to a machine so you don't have to think, and then handing the other person the output.
• 20:57
  The introspection paper said a model's confident answer isn't a window into a mind.
• 21:01
  The agent-patterns talk said trust comes from showing your work.
• 21:05
  This post is the human version of both.
• 21:07
  When someone forwards you an AI answer they didn't read, they've shown you nothing, and there's nothing behind it to trust.
• 21:15
  The tools got good enough to answer for us this year.
• 21:18
  What I'm holding onto going into tomorrow is the difference between using one to think and using one so you don't have to — because that second use is the one no benchmark scores.
• 21:28
  — Lenar Kess.