Latest / Braid / Fast models, slow developers — and the part of the job that stays yours

Transcript

Fast models, slow developers — and the part of the job that stays yours · Braid

• 0:04
  Pieter Levels — you might know him as levelsio, the indie maker behind a string of small, profitable, one-person products — posted three lines yesterday that Marc Andreessen reposted to a few hundred thousand people.
• 0:18
  Here they are, in full: I don't write code anymore.
• 0:21
  I haven't written code in I think six months?
• 0:24
  I think everyone is like this, no?
• 0:26
  And in a companion post he showed the setup: his laptop and his iPhone all day, just browser tabs into his own sites.
• 0:34
  Everything runs on a virtual private server, synced to his phone, with Claude Code open to fix things or build new ones.
• 0:42
  He works from anywhere.
• 0:44
  Andreessen's entire comment on this was one word: Interesting.
• 0:48
  Two things are tangled together here, one real and one bubble, and they're worth pulling apart.
• 0:54
  The real one: for what Levels actually does — small products, he owns every line, he knows exactly what he wants — I believe him completely.
• 1:03
  That's the work where a capable agent takes over the typing, and you spend your day describing and checking instead of writing.
• 1:12
  I'm not skeptical of that at all.
• 1:14
  The bubble one is that last line.
• 1:16
  I think everyone is like this, no?
• 1:18
  No.
• 1:19
  Not yet, and maybe not ever for a lot of work.
• 1:22
  Anyone who's shipped a big system — a decade of history, a compliance surface, and forty other engineers touching the same files — knows that 'just let Claude Code fix it' isn't where Tuesday goes.
• 1:35
  The distance between Levels's Tuesday and that Tuesday is the whole interesting question.
• 1:41
  And the question I'd actually ask isn't whether you still type code.
• 1:45
  It's what your job turns into when the model writes it — and writes it fast.
• 1:50
  Because if you take Levels seriously, the bottleneck stopped being your fingers a while ago.
• 1:56
  It moved somewhere else.
• 1:58
  There was a talk this week that's the sharpest thing I've heard on exactly where it moved, so let me start there.
• 2:05
  The talk is called Fast Models Need Slow Developers.
• 2:08
  It's by Sarah Chieng, who runs developer experience at Cerebras — the company building those wafer-scale chips.
• 2:15
  About a month ago Cerebras and OpenAI shipped a model called Codex Spark, and the headline number is the whole reason for the talk.
• 2:24
  Codex Spark generates code at about 1,200 tokens a second.
• 2:28
  For comparison, she puts the Claude Sonnet and Opus families at 40 to 60 tokens per second.
• 2:33
  So this is roughly 20 times faster.
• 2:36
  She mentions they had to change the y-axis on the chart just to fit it.
• 2:40
  Her thesis is simple, and it reframes the whole speed race.
• 2:44
  In her words: a lot of these bad habits that we had before that were generating maybe 50 tokens per second of bad code — unless we fix them, they're going to start generating 1,200 tokens per second of bad code.
• 2:58
  So what are the bad habits?
• 2:59
  She lists the ones we all picked up because generation was slow.
• 3:04
  Writing one giant prompt and trying to one-shot the whole thing.
• 3:08
  Making huge commits.
• 3:09
  Running ten agents on screen at once, all of them spinning, thinking.
• 3:13
  And then there's the social-media flex — somebody running six terminals at once, a 500-agent coding swarm, or eight agents across five screens.
• 3:23
  Her verdict on all of it: the reality of what is happening in all these setups is that we're generating massive amounts of code that nobody is verifying.
• 3:33
  The old slow workflow, she says, was — you spawn a session, you go get a hamburger, you scroll Twitter, and you come back.
• 3:40
  That was fine when the model was slow and you were waiting anyway.
• 3:45
  It isn't fine when the model spits out a thousand lines while you're picking toppings.
• 3:50
  Here's where it flips the hype on its head, and it's why I wanted to lead with it.
• 3:56
  Her playbook for fast models is mostly about slowing the human down and being more deliberate, not less.
• 4:02
  A few of the concrete moves.
• 4:04
  First, validation becomes free, so you do it everywhere.
• 4:08
  Her line: at 1,200 tokens per second, a model like Codex Spark makes validation basically free.
• 4:14
  There is no excuse and no reason why you should not be doing things like this.
• 4:19
  Linting, pre-commit hooks, diff reviews, and browser-based testing — baked into every step instead of saved for the end, because each check now costs you almost nothing in wall-clock time.
• 4:31
  Second, orchestrate by model strength.
• 4:33
  Use a big, smart model for planning and long-horizon reasoning, and the fast model as the executor.
• 4:40
  When a session goes well, capture it as a reusable skill, so the fast agent can repeat a known-good workflow instead of improvising it again.
• 4:49
  Third, and this one's fun, cherry-pick.
• 4:51
  Her words: I can have it generate 15 versions in the same time that it would have taken the previous model to generate one version, and I can cherry-pick the version that I like the best.
• 5:03
  Spin up five sub-agents, get 75 versions, and keep the best one.
• 5:08
  She calls it a way to artificially induce taste — useful when you want variety, like design directions or architecture options.
• 5:16
  Fourth, stay in the driver's seat.
• 5:18
  The AI should always be helping you make decisions, not the other way around.
• 5:23
  Sit with two or three sessions and actually steer them — ban the model from deleting files, cap the diff size, and tell it exactly what to touch: only change this, leave the types alone for now.
• 5:35
  And fifth, context management gets more urgent, not less.
• 5:39
  Her math: if it used to take ten minutes to fill your context window, divide by twenty — now you're hitting compaction in 30 seconds, and compaction is where the agent loses track of what it knew.
• 5:52
  Her words: you can't get away with sloppy practices anymore.
• 5:56
  Her fix is to externalize the agent's memory into a handful of plain files: one defines the sub-agents, one holds the full plan as a checklist, one tracks what's done and what's next, and one handles verification.
• 6:09
  A fresh session always knows where to pick up.
• 6:12
  What I take from all of it is this.
• 6:15
  The flex is the swarm, but the craft is the discipline.
• 6:18
  Speed doesn't remove the engineer from the loop; it punishes you faster when you remove yourself.
• 6:24
  The bottleneck moved from typing to deciding — which is exactly what Levels was describing, just from the other end.
• 6:32
  And if deciding is the job now, then the worst move you can make with a 20-times-faster model is to stop paying attention.
• 6:40
  Two money stories landed this week that are really the two ends of the same pipe.
• 6:45
  Start with the cheap end.
• 6:47
  DeepSeek announced that the 75% discount it had been running on its V4-Pro model is now permanent.
• 6:53
  Back in April they framed it as a promotion; as of yesterday, the promo just becomes the price.
• 6:59
  After the promotional period ends at the end of May, V4-Pro lands at one quarter of its original rate.
• 7:05
  By the secondary reporting I've seen, that's somewhere around 44 cents per million input tokens and 87 cents per million output tokens, which puts a frontier-class model among the cheapest you can call.
• 7:18
  They paired it with a roughly 90% cut to the cost of input cache hits across the whole API.
• 7:24
  That cache-hit detail is the one I'd flag for anyone running agents.
• 7:28
  If your workload re-sends a big stable chunk of context on every step — a system prompt, a codebase, or a long set of instructions — the cache discount is where the real savings live.
• 7:40
  That repeated context is most of what you pay for in an agent loop, so a 90% cut there is a different cost model, not a coupon.
• 7:48
  Now, the framing around this, reported by a few outlets, is that DeepSeek is going after developers frustrated with Western providers — the rate limits, the restrictions.
• 7:59
  I'd take that as the marketing narrative and hold it loosely.
• 8:02
  What's verifiable, and what actually matters to you, is the price and the cache economics.
• 8:08
  The caveat that doesn't go away: where the model runs and who sees your data is a live governance question for a lot of teams, and a low price doesn't answer it.
• 8:18
  The other end of the pipe is NVIDIA.
• 8:21
  In its most recent quarter — the first quarter of fiscal 2027 — NVIDIA reported about 81.6 billion dollars in revenue, up 85% from a year earlier.
• 8:30
  And folded into the reporting structure was a change: they took Gaming, which had always been its own category, and merged it into a broader bucket they're calling Edge Computing.
• 8:41
  That new bucket — which now lumps together GeForce gaming cards, AI PCs, workstation parts, consoles, robotics, networking, and automotive — came to about 6.4 billion for the quarter.
• 8:53
  Think about that.
• 8:54
  Gaming built this company.
• 8:56
  GeForce is why most of us first knew the name.
• 8:58
  And it's now a line item inside a grab-bag category, because next to the data-center business it's a rounding error.
• 9:06
  NVIDIA was careful to say they're not walking away from gaming hardware, and I believe them — RTX cards keep shipping.
• 9:13
  But they're no longer telling the gaming story to investors.
• 9:17
  They're telling the accelerated-computing story, full stop.
• 9:21
  Put the two together and you get a clean picture of where the money sits.
• 9:25
  The shovels — the data-center silicon — are where the growth is, to the point that the consumer line gets absorbed into a footnote.
• 9:34
  And the inference built on those shovels is racing toward a price floor, with DeepSeek dragging frontier-class output down to cents.
• 9:42
  For a builder, that second trend is the one you can actually spend.
• 9:46
  Running agent loops at volume gets cheaper every quarter, and the cache economics reward you for keeping your context stable instead of rebuilding it on every call.
• 9:57
  On Wednesday, Jack Clark gave a lecture at Oxford.
• 10:00
  Clark is a co-founder of Anthropic and the person behind Import AI, which is one of the more sober newsletters in this space.
• 10:08
  He's not a hype account, which is part of why the predictions he made are worth engaging with rather than waving off.
• 10:15
  Here's the spread, as reported by the Guardian.
• 10:18
  Within 12 months, he expects an AI system to work with humans on a Nobel-prize-winning discovery.
• 10:24
  Two years out, bipedal robots helping tradespeople.
• 10:28
  Inside 18 months, companies run solely by AIs and generating millions of dollars in revenue.
• 10:33
  And by the end of 2028, AI systems able to design their own successors.
• 10:38
  He described a vertiginous sense of progress.
• 10:41
  He also didn't soft-pedal the other side.
• 10:43
  He said there remain plausible scenarios where the technology has, his words, a non-zero chance of killing everyone on the planet, and that it's important to clearly state that that risk hasn't gone away.
• 10:56
  He mentioned that Anthropic recently launched a model called Mythos that proved, quote, alarmingly capable at exploiting cybersecurity weaknesses.
• 11:05
  And he said he'd prefer to slow the whole thing down to give ourselves more time as a species — but that it won't happen.
• 11:13
  Too many actors and countries are locked in competition, and commercial and geopolitical rivalry drowns out the existential questions.
• 11:22
  Let me steelman the predictions and then push on them.
• 11:25
  The strongest case for Clark is that he's been roughly directionally right before, and he's framing these as a spread of bets, not a single prophecy.
• 11:34
  Some will land, some won't, and the point is the slope.
• 11:38
  Where I get skeptical is that the predictions aren't all the same kind of claim, and they're not equally falsifiable.
• 11:45
  AI helps make a Nobel-winning discovery in 12 months is the soft one — you could declare that true after the fact for almost any prize-adjacent result where a researcher used a model somewhere in the pipeline.
• 11:58
  It's the kind of prediction that's hard to lose.
• 12:01
  The ones that count, the ones I'd actually hold him to, are the falsifiable ones: a company run end-to-end by AI, with audited books, clearing serious revenue inside 18 months; and AI systems designing their successors by 2028.
• 12:16
  Those you can check.
• 12:17
  If a company actually run by AIs is posting audited revenue a year and a half from now, that changes my picture of the world.
• 12:25
  I don't expect it on that timeline.
• 12:27
  I'd love to be wrong.
• 12:29
  But the moment from that Oxford event that stuck with me wasn't Clark.
• 12:33
  It was the counterpoint from the person who co-hosted him.
• 12:37
  Edward Harcourt, who directs Oxford's Institute for Ethics in AI, warned that AIs doing more and more for us risks what he called cognitive atrophy — a weakening of human judgment and decision-making.
• 12:49
  And he argued for a different kind of system, what's sometimes called Socratic AI: models built to make the human do more of the thinking, not less.
• 12:59
  And this is where two of today's threads rhyme.
• 13:02
  Sarah Chieng, in a completely different room, talking about 1,200 tokens a second, landed on the same instruction: the AI should help you make decisions, not the other way around.
• 13:13
  Harcourt, worrying about a whole society, lands in the same place — build the tools so people keep deciding.
• 13:20
  Same worry, two altitudes.
• 13:21
  The fast-model engineer and the ethics professor are both telling you not to hand over the part of the job that's actually yours.
• 13:30
  I don't know which of Clark's dates are right.
• 13:32
  My read is that the timelines are the least interesting part.
• 13:36
  The interesting part is the instruction hiding underneath all of it, and it isn't about the models.
• 13:43
  It's about whether the humans stay in the loop on purpose.
• 13:46
  While the frontier labs are showing off 1,200 tokens a second on wafer-scale hardware, there's a parallel speed story happening on the gear in your closet.
• 13:57
  A developer who goes by Anbeeld shipped version 0.2.0 of a project called BeeLlama, and the numbers turned heads in the local-model crowd.
• 14:06
  On a single RTX 3090 — a four-year-old gaming card with 24 gigabytes of memory — they're getting Qwen 3.6, the 27-billion-parameter model, up to 164 tokens a second.
• 14:17
  That's about 4.4 times the baseline from llama.cpp, the standard local runtime.
• 14:22
  Gemma 4, at 31 billion parameters, hits about 177 per second, almost five times baseline.
• 14:28
  And prompt processing speed stays near baseline, so you're not paying for the gain on the way in.
• 14:35
  The mechanism is speculative decoding, done carefully.
• 14:39
  The idea: a small, fast draft model guesses the next several tokens, and the big target model verifies that guess in parallel.
• 14:47
  When the guess is right, you got several tokens for roughly the cost of one.
• 14:52
  This release is a pile of careful engineering on top of that idea: lower draft overhead, cached key-value projections from the draft model, and stricter checking that the draft and target actually agree.
• 15:06
  There's also a safer fallback to full computation when the grammar, the sampler, or a reasoning step needs it.
• 15:13
  The caveat with all speculative decoding is that the speedup depends on acceptance rate — how often the draft's guesses are right — and that's workload-dependent.
• 15:24
  Unusual or heavily-reasoned outputs accept fewer guesses and fall back toward baseline.
• 15:30
  So that 164 is the good case, not a promise for every prompt.
• 15:34
  But the good case matters, because it's the difference between a local model being a toy and being something you'd actually put in an agent loop.
• 15:44
  One commenter asked the right follow-up: can this hold up for 200-thousand-token agentic coding chats?
• 15:51
  That's the test that matters — long context, real work, on hardware you own.
• 15:56
  Another just said, squeezing that 3090 like a lemon, which is about right.
• 16:01
  I find this the more grounding of the two speed stories.
• 16:05
  The Cerebras number is a thousand-plus tokens a second on a chip you rent from a data center.
• 16:11
  This one runs at 164 on a card you can buy used, running a model whose weights you hold.
• 16:17
  Both numbers hold up.
• 16:18
  But only one of them runs when the API is down, or when you flatly don't want your code leaving the building.
• 16:26
  That gap has been the local-model crowd's whole bet, and every speedup like this one narrows it.
• 16:32
  Yesterday we spent time on OpenClaw — the open agent runtime and its firehose of pull requests.
• 16:38
  There was a talk this week that solves a problem anyone running one of these has hit.
• 16:43
  It's from Sally Ann O'Malley at Red Hat, and it's called Lobster Trap: OpenClaw in Containers, from local to Kubernetes and back.
• 16:51
  The problem she opens with is one you'll recognize.
• 16:54
  Sharing a good agent setup usually means handing a coworker a pile of markdown files, config, and YAML, and hoping they reproduce what you have.
• 17:03
  Anyone who has tried this knows how it ends — their version drifts from yours, their agent behaves differently, and you can't tell why, because the setup was never a single thing you could pin down.
• 17:15
  Her answer is to make the agent setup a container image.
• 17:18
  On your laptop, Podman spins up a sub-agent in about two seconds from a single command.
• 17:24
  Flip a flag and the same image runs on Kubernetes for the team — the same image the whole way through.
• 17:30
  Your personal config stops being a dotfile you message around and becomes the team baseline that everyone runs identically.
• 17:37
  Secrets get handled in two layers: Podman secrets for the API keys on the host, and OpenClaw's own secret references inside the agent.
• 17:46
  This is the maturation move, and it's the kind of thing that tells you a tool is growing up.
• 17:51
  The agent's configuration stops being personal folklore and becomes a versioned, deployable artifact.
• 17:57
  The constraint it actually solves is reproducibility, which sounds dull right up until your teammate's agent does something yours never would, and you've spent an afternoon discovering it was a config file that diverged three weeks ago.
• 18:12
  It connects to the thread running through this whole episode.
• 18:15
  The agent is turning into something you provision and govern, not a clever script you ran once.
• 18:21
  And the people thinking hardest about agentic coding right now are spending a surprising amount of energy on the parts nobody demos: how you share a setup, how you verify the output, and how you keep the human in command.
• 18:35
  The capability is mostly here.
• 18:36
  The work that's left is making it reproducible, checkable, and safe to hand to someone else.
• 18:42
  Let me end outside the bubble, because two small things this week reminded me how far inside it we are.
• 18:48
  The first is a post on the singularity subreddit.
• 18:51
  A data engineer — undergrad in computer science, master's in statistics — wrote in a little rattled.
• 18:58
  She'd suggested, in some non-tech forum, that someone just use AI to fix a broken bra-size calculator, the way any of us would reach for it without thinking.
• 19:07
  The reaction was hostile enough that she came to ask, basically, for a reality check: is AI seen as evil out there?
• 19:14
  The top reply, with a few hundred upvotes, lands hard, because it's the view from outside and it's not stupid.
• 19:21
  Quote: For a lot of people, there's limited upsides to AI right now.
• 19:25
  They see it being forcibly shoved into all their technology by billionaires who are siphoning the planet's energy and water to build massive and opaque supercomputing complexes in their backyards.
• 19:38
  They see people — particularly creative people but more and more everyone — getting pushed out of their livelihoods.
• 19:45
  And then: while strides are being made in medicine and math, right now it's not serving most people, and in many cases it's causing harm.
• 19:53
  You can argue with pieces of that.
• 19:55
  But I don't think you get to dismiss it.
• 19:58
  From inside our world — where the conversation is 1,200 tokens a second, and AI-run companies in 18 months, and which agent harness has the better container story — it is easy to forget that for most people, AI is something happening to them, not something they wield.
• 20:14
  They didn't get the fast model.
• 20:16
  They got the layoff, or the energy bill, or the slop in their feed.
• 20:20
  The second one is smaller, and I can't stop smiling at it.
• 20:24
  Niloofar, an AI researcher, posted that she'd been burnt out, flew to Copenhagen on short notice to detach, and was sitting in a random park taking a photo when she realized the couple next to her were deep in conversation about — her words — world models and grounded video gen.
• 20:41
  Even the park bench in Copenhagen is in the bubble now.
• 20:45
  So here's the one thread I didn't expect to find this week.
• 20:48
  Three people who'd never be in the same room — Sarah Chieng at a developer conference, Edward Harcourt at an Oxford ethics lecture, and an anonymous Redditor explaining why normal people are wary — all landed within a few feet of the same idea.
• 21:03
  When the machine gets fast and capable and cheap, the only job that stays yours is being the one who decides.
• 21:10
  Chieng says it to keep your code clean.
• 21:12
  Harcourt says it to keep your judgment intact.
• 21:15
  The Redditor says it as what people are afraid of losing.
• 21:19
  They're all right.
• 21:20
  So make things that earn the upside for the person who isn't in the bubble.
• 21:25
  And whatever the model can do this year, stay the one deciding what's worth doing.
• 21:30
  — Lenar.