21:55Cole Medin · Tutorial
Google Just Dropped a Masterclass on Agentic Engineering
Cole Medin's rapid-fire breakdown of Google's 51-page AI coding playbook — the model is only 10%, the harness is everything.
June 25thThe argument in one line.
The productivity unlock from AI coding tools requires the same organizational transformation computers demanded in the 1990s — not an AI tool on the side, but AI at the literal center of every workflow.
Read if. Skip if.
READ IF YOU ARE…
- An engineer who is using Claude Code daily but still running one agent at a time and manually approving most tool calls.
- A product manager, designer, or non-engineer who suspects AI coding tools might be relevant to their work but hasn't tried them yet.
- An engineering leader trying to understand how to restructure team processes — not just add AI to existing ones.
- Someone who adopted plan mode early and hasn't revisited whether auto mode might suit them better now.
SKIP IF…
- You want a technical deep-dive into Claude's model architecture — this is a workflow and product philosophy conversation.
- You're looking for beginner setup instructions; the conversation assumes you're already using Claude Code actively.
The full version, fast.
One year in, the Claude Code team's biggest insight isn't a feature — it's a habit: every mistake goes into CLAUDE.md as a skill, not just a one-time fix, so the agent compounds over time. From there the conversation traces two years of workflow leaps: from permission-prompt-everything to auto mode (safer because the human only sees genuinely ambiguous requests), from manually running CI to routines that proactively file bug-fix PRs before you notice the bug, from six terminal tabs to a single agent view running hundreds of parallel agents mostly from a phone. The throughline is that the full productivity gain requires reorganizing work around AI at the center — not bolting it on the side.
Free for members
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.
00:00 – 01:10
01 · Origins and evolution
From two Slack reactions to agent trees. The compound habit: every mistake goes into CLAUDE.md, not just a one-time fix.
01:10 – 03:14
02 · Verification for agents
Verification isn't lint or unit tests — it's building a skill that lets the agent actually run what it just built. Demo: desktop app skill with computer-use click-through.
03:14 – 04:48
03 · Roles merging beyond engineers
Designers file PRs, PMs make app changes, finance runs projections in Claude Code. Product taste is becoming the differentiator.
04:48 – 06:43
04 · Routines as autonomous CI/CD
One engineer's voice-mode routine monitors every GitHub issue and proactively files fix PRs. A second catches bug reports older than five hours. 'Another Claude already fixed this.'
06:43 – 08:10
05 · Auto mode over plan mode
Newer models don't need an explicit planning step. Auto mode routes permission requests to a classifier — human only sees the genuinely ambiguous ones.
08:10 – 10:23
06 · Securing auto mode
Thousands of annotated transcripts trained the classifier. Red teamers tried to prompt-inject. Attacks became evals. Internal teams ran a second round.
10:23 – 11:06
07 · Loop: the next leap
Leap 1: talk to an agent instead of writing code. Leap 2: talk to a loop that prompts the agent for you. Two big leaps in eighteen months.
11:06 – 13:30
08 · How engineering orgs are changing
The 1990s computer-adoption Harvard Business Review case study applies directly: you can't keep AI on the side. Throw out the filing cabinet; put AI at the center.
13:30 – 14:20
09 · Product or engineering?
Everyone is going to be both. The differentiator is curiosity, product taste, and desire for end-to-end ownership.
14:20 – 16:05
10 · Working with hundreds of agents
Agent view replaced six terminal tabs. Remote Control means about half of engineering happens on a phone. Agents started with voice while walking to get coffee.
16:05 – 17:17
11 · Context minimalism
Context engineering was a weaker-model workaround. Today: minimal system prompt, minimal tools, let the model pull context. Over-prompting is micromanagement.
17:17 – 18:07
12 · What's next
Agents running longer, more autonomous, in larger parallel fleets. Today's form factor will look dated within a year. Ideas will come from the community.
Lines worth screenshotting.
- Every time Claude makes a mistake, document the fix in CLAUDE.md rather than just correcting it in place — that's how an agent improves permanently instead of repeating the same error.
- Verification for agents isn't unit tests or lint — it's building a skill that lets the agent actually run the thing it just built and observe whether it works.
- Auto mode is more secure than manual permission review because humans stop paying attention after approving 99% of requests; a classifier only escalates the genuinely ambiguous ones.
- Routines have automated CI/CD and code review to the point where the team regularly hears 'another Claude already fixed that' before the human even reads the bug report.
- The 1990s computer-adoption research applies directly: you don't get productivity gains by keeping AI on the side — you get them by putting it at the center of every business process.
- Context engineering was a workaround for weaker models; with current models, giving a minimal system prompt and minimal tools and letting the model pull context is strictly better.
- About half of engineering at Anthropic now happens on a phone via Remote Control — agents run on a desktop while the engineer walks around and checks in.
- Roles are merging: designers file PRs, PMs make app changes, finance runs projections in Claude Code — because the model lowered the barrier enough that product taste matters more than syntax.
- The two big leaps in eighteen months: first, talk to an agent instead of writing code directly; second, talk to a loop or routine that prompts the agent for you.
- Over-prompting is micromanagement — giving the model too much context constrains it from finding a better path to the same outcome.
- The form factor of today's tools will look as dated as the very first Claude Code interface within a year; the next form factors will come from the team and community, not the product leads.
What a year of Claude Code actually taught them.
WHAT TO LEARN
The biggest gains don't come from using a better AI tool — they come from reorganizing how work happens so that AI sits at the center of every process, not beside it.
01Origins and evolution
- Every time Claude makes a mistake, write the fix into CLAUDE.md rather than just correcting it in place — the agent compounds across sessions only if its lessons are written down.
02Verification for agents
- Verification for agents is not lint or unit tests. It is building a skill that lets the agent actually run, interact with, and observe the thing it just built.
03Roles merging beyond engineers
- Product taste, curiosity, and end-to-end ownership are becoming the primary differentiators as coding syntax becomes a commodity; roles are merging across engineering, product, design, and finance.
04Routines as autonomous CI/CD
- Routines — background agents triggered by events like new GitHub issues — are the first obvious application of autonomous agents; the team now routinely discovers that a bug has already been fixed before they notice it.
05Auto mode over plan mode
- Auto mode is counterintuitively more secure than manual review: humans stop paying attention after approving 99% of requests, so routing to a classifier means the human only sees what genuinely requires judgment.
06Securing auto mode
- Security for agentic systems requires red teamers actively constructing the most sophisticated attacks possible, converting each attack into an eval, then running internal teams through a second round — known-wild vulnerabilities are not enough.
07Loop: the next leap
- The two-leap framework: first you talk to an agent instead of writing code; then you talk to a loop or routine that prompts the agent for you. Both happened inside eighteen months.
08How engineering orgs are changing
- Organizational transformation requires putting AI at the center of every process, not adding it on the side — the same transition that took a decade with computers is happening in years because work is already digital.
09Product or engineering?
- Product taste, curiosity, and desire for end-to-end ownership are the differentiators — everyone is going to need both product and engineering sensibility.
10Working with hundreds of agents
- Remote Control enables genuinely mobile-first engineering — starting agents with voice while walking around is already how about half of one team's engineering work gets initiated.
11Context minimalism
- Context minimalism: with current models, a minimal system prompt and minimal tool set outperforms an elaborate front-loaded context — over-prompting prevents the model from finding better paths.
12What's next
- The form factor of today's tools will look as dated as the original Claude Code interface within a year; expect the next two leaps to be as surprising as the last two.
Terms worth knowing.
- Auto mode
- A Claude Code operating mode where tool-call permission requests are routed to a classifier model rather than shown to the human; only genuinely ambiguous or risky requests escalate. Replaces the original prompt-everything model.
- Routine
- An autonomous agent loop that runs continuously in the background, listening for a trigger (like a new GitHub issue or a bug report older than five hours) and acting on it without human initiation.
- Loop
- A Claude Code feature that abstracts one level above talking to an agent — you describe a goal to a loop, and the loop prompts the agent repeatedly until the goal is met.
- CLAUDE.md / skill
- Project-level instruction files that persist across Claude Code sessions; recording a fix in CLAUDE.md rather than applying it once is how an agent's behavior improves permanently.
- Remote Control
- A Claude Code capability that lets you connect to and direct agents running on a separate machine — in practice, managing a desktop agent from a phone.
- Context minimalism
- The current best practice of providing the smallest useful system prompt and fewest tools, letting the model pull in context on demand, rather than front-loading everything it might need.
- Agent view
- A Claude Code interface element that shows multiple parallel agents running simultaneously; replaced the pattern of maintaining six separate terminal tabs with six git checkouts.
Things they pointed at.
01:40toolCLAUDE.md
10:20toolClaude Code Agent SDK
11:43bookHarvard Business Review — computers and productivity (1990s)
14:20toolClaude Code agent view
15:07toolClaude Code voice mode
Lines you could clip.
01:00
“Every single time Claude makes a mistake, I don't tell Claude to do it differently. I tell it to write it to the CLAUDE.md or to make a skill.”
08:09
“Auto mode is actually more safe than reading every single permission prompt because it means you're only paying attention to the most important thing.”
13:24
“Claude is just at the center of everything. Whenever I have a question, I ask Claude. Whenever I write code, I use Claude. Whenever I need a code review, Claude does it.”
15:04
“I don't have a to-do list anymore. Claude just builds everything. And so my job is to come up with these ideas, and it's just so fun.”
16:04
“I would not have expected six months ago that probably half my engineering I do on my phone.”
Word for word.
Read-along
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
When we first released QuadCode, it was like a little video. And I remember we're supposed to get to Slack, and there was, like, two people that gave, like, the reactions.
And, like, people were, like, excited. I saw that That was really cool, especially for my very easy engineering tasks. I was quite good at it.
That's, like, a really nice way to say that it wasn't really good.
I can't believe it's only been a year since we first launched Cloud Code. It's hard to remember what what that was like. Like, it it is it it's so different than what we're doing today.
Like, now I just have, like, armies of agents that are doing stuff. Like, I'm prompting one agent or I have, like, an agent that's, like, prompting agents that's prompting agents. And it's, like, a tree of, like, thousands of agents.
But it's I think it's just, like, the most important idea when working on this stuff is, like, every single time Quad makes a mistake, I don't tell Quad to do it differently. I tell it to write it to the QuadMD or to, like, make a skill or or something to do it differently.
And if you can do this, then Quad can just, like, run forever. And I I think the other thing that we kinda realized is the verification is is really important. Like, we didn't realize that.
I hear this come up a lot with
developers and enterprises that we meet with.
Um, what are your tips for making a really good making Cloud Code really good at verification? I sort of feel like this is this thing that just like everyone misunderstands because whenever we talk about verification, people are thinking like unit tests or they're thinking like Lint or like type check.
These are the things that are obviously really easy to automate and these are the things that were already automated. But, actually, when we talk about verification for agents, it's something slightly different. It's like, can the agent run the thing?
It takes a little bit of mental work to figure out how exactly do you do this because it's often not straightforward. And I think that's like that's one of the challenges. I remember with with OPUS four, Claude tested itself.
And we we we just, like, hooked it up to OPUS four, and I was like, Claude, build the feature and then test yourself in, like, Bash. And it opened a little Claude CLI and tested its own feature. And I was just like, woah.
It's crazy. Like, now now we're so used to it. Like, now, you know, now we now we have these loops going for, know, you like, iOS simulator and the Android simulator and, like, computers for desktop.
Like, it's it's not surprising.
But back then, that was crazy. How how are, like, how how are you doing it? So I've been mainly hacking on the desktop app these days, and one of the engineers on the team actually added this desktop development skill that teaches Quad how to run the local desktop app.
Mhmm. And I've been having it use it, and it still runs into issues or, like, bugs with the staging environment sometimes.
And so what I have it do is in those cases, I have it read Slack and understand, hey. Is is staging down right now? Or is there has someone else already hit this?
And then when it debugs the whole issue, I tell it to update the desktop development skill. What this skill does is Cloud actually spins up a local desktop app, and it uses computer use to click around on it. And so when I add a new UX, it clicks around to invoke the new UX.
It also tests edge cases. And when there's an issue, it fix it, sizz it, and rechecks. This is, like, honestly, one of my favorite things about this team is everyone codes.
I I I have never been on a team where, like, like, the my my PM would code. And it's, like, crazy. And, like, your code is, like, really good.
Like You're too nice. But I I also just feel like it's it's also just becoming easier because it's, like, essentially, Claude writes the code. And so what matters a little more is, like, what what's the idea that you have?
And I I feel like if you're a person that has, like, the product context and the business context and you're thinking about the design and the user, you're just gonna come up with better ideas. It's kind of like all the roles are merging.
I remember seeing Megan, our designer's PRs, and I was just horrified at the beginning. I was like, oh my god. Why is Megan putting up PRs?
And then she was like, yeah. Yeah. I'm just like, I'm fixing the button.
And I was like, okay. Alright. Well, the code looks good.
So maybe it's maybe it's fine. And I I feel like now it's just like it's totally normal. Yeah.
But we see this across all the enterprises we talk with. Like, it's the engineers adopt Cloud Code first,
and then the the edge adjacent roles look over their shoulder, they're like, woah. This thing is very powerful. Let me try it out.
And we found it's crazy. We found that, like, our designers are more productive, making prototypes and making changes directly in the app instead of paying an engineer. PMs are making changes in the app.
Mhmm. Like, our finance team runs in Cloud Code. They do their projections there.
Mhmm. Um, data science, uh, like, if you talk with our data scientists, it's so cool.
It's just like everyone just has Cloud Codes up on their screens. Yeah. I feel like it's it's remarkably versatile for for different roles.
What do feel like nowadays
are, like, the use cases that are that are pushing the limit? One that I'm super excited about is routines.
There's one engineer on our team who launched voice mode across all of our products. And he has this routine set up that just listens for every ticket that come every GitHub issue, every bug report about voice mode, and his call just picks it up, proactively puts up a fix, and then pings the PR to him.
And when he got that working for voice mode, he thought, okay. We're getting a lot of other feedback that isn't being responded to. So he also set up a routine to listen for that.
So I shipped this small feature, and there was, an edge case in it that I didn't see. And so someone filed a bug for it, and I was gonna get it get to the bug that night. And as my quad was working, it said, wait a second.
Another quad has already fixed this. And I was like, how is this possible? Like, I've never talked to him about this feature before.
And so I pinged him, and I was like, how did you fix this so quickly? And he said he has another routine that just looks for bug reports that haven't been responded to in five hours and puts up a fix, and he merges the ones that are easy to verify.
Claude tells me this, like, all the time now. That someone else has already fixed it. There's always, another versus Claude that's working on it.
It's like yeah. That's been one of the changes. I I feel like we're a while ago we were trying to figure out like how to use routines and I feel like just like the agent SDK was this first idea that we could use quad code programmatically, but I feel like at the beginning it it just wasn't obvious how do we use it, what do we use it for.
And I I think routines are the first really obvious application. And I don't know. Like, it it just does, like, all the code review.
It it babysits, like, every PR. You remember back in the day, you used to actually have to, like, respond to code review comments? You used to have to, like, fix CI.
You used to have to rebase. Yeah. Like, I I haven't done that in a long time.
Yeah. When you're in the CLI and you're synchronously working with Cloud, what are the your go to features?
Okay. What they used to be is plan mode. I don't use that anymore.
I use instead? Auto mode. Auto mode.
It's the best. Instead of plan mode? Instead of plan mode.
Yeah. Because I the newer models, they don't actually need, like, a planning step anymore. I think this was really important for, like, OPUS four through maybe 4.5.
Then I think starting with four six and definitely with four seven, it just doesn't need that planning step. I think some people still use it. They like to have that artifact.
I don't I don't use it. And I just do auto mode for everything because then I I start my quad, it starts to work, and then I just, like, move on to the next quad. And I don't have to sit there and watch it.
But from the very earliest days, we had this, like, permission prompt model for quad code. Right? Like, it runs a tool and then it asks you, like, hey.
Are you okay running this tool? And you had to say yes or no. And at the time, that was kind of the best we had a year and a half ago because we didn't have, you know, classifiers.
The model was not as well aligned as it is today. So auto mode was just such a it was such a big step up because act actually, you don't wanna read most of these requests. Just routing it to a different model and having it check for security works so much better.
Yeah. And if a thing, like, is a little sus or, you know, this isn't a command that you think you wanna run or it's not safe, the model will just deny it.
And then you can go back and you can allow it later. I think this has been one of those, like, sub changes. We we just there's no way we could have done this a year and a half ago.
It's just human nature when you accept 99% of requests
that your eyes just glaze over when you read it. And so actually, we feel that automotive is more safe than reading every single permission prompt because it means that you're only paying attention to the most important thing and not, like, being spammed a bunch of things that are just 99%
yes. I think security is one of these things, like, you can talk about it, and then it's a totally different thing to actually do it correctly because it just doesn't always look the way that you think it's gonna look. And it's just all about, like, always red teaming, always pen testing, always looking you know, always having a threat model and then using that to figure out, you know, how is this thing gonna get attacked?
How are people gonna get prompt injected? Exactly. And I I just feel like, like, the team is just, like, obsessed with this.
And it it it's so important because as a result, I just trust the agent to run. And I can move on, and I can just have, like, a second agent. And if I didn't trust it, then I just wouldn't have been able to do that.
And internally,
to actually get auto mode out to our users, we needed to really trust it first. And so what we did was we collected thousands of transcripts of, like, an entire agent trajectory and a permission prompt and had auto mode classify whether or it was safe.
And it was extremely good at this, so then we got red teamers, and we asked them to try to prompt inject and try to hack the code base. And we used this to create evals and made sure that all of these were denied.
And then we had our own internal teams try to prompt, inject, and hack Cloud Code, Cloud Code's auto mode. And then we improved auto mode to make sure that we caught all of these. So it's not only just protecting you against the vulnerabilities that are out there in the wild today,
but the the most intelligent attacks that we can construct. Yeah. I mean, it's like it's honestly like a weird approach.
I I I feel like there's, like, all these features the last year where the first time someone pitched it, I was like, no no way. That's not gonna work. And I feel like over time, I just learned, like, I'm actually wrong, like, so often now because, like, building on the model is so weird.
Yeah. It's just like all this, like, engineering stuff that I've learned over the years, like, so much of it, I just have to, like, throw out. And this is just, like, part of what the job is now.
Like, we're building on a new thing, and we just have to relearn it. And I automotive was definitely one of these. I was like the first time I heard it, was like, route the prompt to a model?
No way. That's not gonna work. And then it actually turns out, empirically, it works really, really well.
I heard you also love Loop. I yeah. I I love Loop.
How do you use it? I think for Loop, there's this transition that we went through, like, a year and a half ago where we were like, alright. There's source code.
But actually, the thing an engineer should interact with, maybe it's not the source code. Maybe it's the agent.
And so we made this leap of like, I don't write the source code. I talk to an agent and the agent writes the source code for me. And I think right now what's happening is we're making the next leap.
I don't talk to an agent anymore. I talk to a loop or I talk to a routine, and it prompts Quad for me.
And it's just it's crazy. I mean, it's been like it's a year and a half, and this was, two big leaps.
If you take, like, a step back, how are you seeing entire engineering orgs change? I'm gonna put I'm gonna put on my business cat hat. I I I have this, like, favorite case study.
This is, a Harvard business review from the nineties, and they were talking about, like, computers are here. Why are we not seeing the productivity benefits?
And it's just this, like, amazing snapshot into, like, what it actually felt like at the time. Because, like, you know, people used to use mainframes. At some point, com companies switched to personal computers.
It was sort of a new thing, and the companies were trying to figure out how to how to use it, the same way they're trying to figure out how to use AI right now. And it turned out that to get the productivity benefits from computers, what you had to do isn't like you have your paper filing cabinet and your, like, paper and pen business process, and then there's, like, a computer on the side that does something.
Actually, what you have to do is you throw out the filing cabinet, you have to throw out all your paper and all your pens, and then you put a computer in the center. And everything has to run through the computer. It has to be at the center of every business process.
And I I feel like at Anthropic, we do this thing where when you onboard, you don't ask people questions. Like, no one asks me questions when they onboard.
You probably have the same thing. They ask Quad. And this is kinda weird.
Like, this is the first company I've been at like that. And I feel like for us, Quad is just at the center of everything. Whenever I have a question, I ask Quad.
Whenever I write code, I use Quad. Whenever I need a code review, Quad does it. Whenever I need a security review, Quad does it.
Whenever I need to, you know, fill out a form or something, CoWork does it. So it's just like Quad is at the center of everything. And I I feel like the companies that are really figuring it out, and there's a bunch of them now, they're just putting Quad at the center of it.
And I think for computers, the transition took ten to fifteen years. But actually for AI, because so much of our work is already ready digitized,
and Claude can use a computer, and it can write code and run code, this transition's happening a lot faster. I think it's just, like, really it's just really exciting. Like,
I feel like now I don't have to bug people anymore. And when I interact with people, it's because it's, like, fun and I get to collaborate with them on stuff and we get to create something together. It's not that, like, I need them.
I need something, you know, from them because, like, Claude can actually do a lot of that stuff now. And I also feel like as an engineer, I've just never had this much fun doing engineering. Because the, like, the tedious part, I don't have to do.
Like, I'm just coming up with ideas. I'm talking to customers. And every idea, I don't like, I don't have a to do list anymore.
Like, Claude just builds everything. And so my job is to come up with these ideas, and it's just so fun. Okay.
So here's a question. Is the future a product or engineering? Like, is everyone gonna be a PM, or is everyone gonna be an engineer?
Everyone's gonna be both.
I I feel pretty strongly that these roles are merging. Like, when we look at our team, our product team all writes code. Our dev role team all writes code.
Our design team all writes code. And then we look at our engineers, and a lot of them ship products end to end. They have an idea for what to build.
They build it. They work with legal and marketing to figure out how we communicate this to the world and make sure it's safe and with security too. And a lot of times, they just see through this whole process end to end.
So I think right now, AI really benefits people who have a lot of curiosity, have a lot of product taste, who love to have this, like, end to end ownership.
And now a lot of people are running, like, hundreds of agents. What are the products that you think people should be adopting as they transition from single to multiple to
hundreds. Until recently, the way that I wrote code was I had, like, six terminal tabs with six git checkouts of the same repo, and then I would just, like, tab between them. Now it's pretty different.
I have, like, one tab. I use the new agent view that we just shipped. It's, like, so good.
And I'm so glad that we took a while to iterate on it to make that really good. And I also use the desktop app because I don't have to fiddle with checkouts that way. It just, like, you know, it it does the work tree cloning.
Like, it it creates the work trees for me. And the thing that I would not have expected six months ago is probably half my engineering now. I do it on my phone.
So I just have, like I have so many agents running that I just start from my phone. I use a remote control, which is, like, amazing now. And, like, I will start something on my computer, and then I'll just remote control in from my phone.
And I'll just, like, walk around. I'll, like, get coffee, and then I'll check-in on my agents, and maybe I'll start another agent. And sometimes I'm, like, talking to someone and we come up with a new idea.
I'll just start an agent on the spot. I'll, like, talk to it with voice mode and just have it build something. And I don't even have to go back to my computer anymore.
I remember when you started doing this because you would actually leave work, have your computer on your desk open, plugged in, screen locked,
and I just thought you would, like, come back to the office at some point to get your computer. But then it would be, like, pretty late, and I was like, maybe you just, like, left it here by accident. And then it happened again the next day, and it happened again the next day, and I was like, wait.
This is so weird because you're landing PR, so your computer is right next to me. And I remember you responding, you're like, yeah. I'm coding from my couch.
Yeah.
That was the week that remote control got really good. Yeah. So another thing that users are asking about all the time is, how do you do context engineering, especially in a large enterprise?
This is a thing. You know, people used to talk about prompt engineering. They used to talk about context engineering.
This is sort of matching where the model was at the time. Back in the days of Sonnet 3.5, you had to prompt engineer. Back in the days of Opus four, you had to context engineer.
But with the models of today, you don't do any of this. You give it the minimal possible system prompt, the minimal possible tools, and then you let the model figure it out.
Like, you just have to give the model some way to pull in the context. I think that's the most important thing.
How do you think about it? I see things very similarly. I'm a context minimalist, so my general philosophy is tell the model only what it needs to know and let it figure out the rest of it.
I think when you give the model too much context, it's kind of like you're micromanaging it. And sometimes the model knows a better way to get to the same outcome, and I personally prefer to give the model that freedom to do that.
And then in general, we're also making our harness more lean so that you have more room for your own prompts
and so that follows your prompts better. There's all these different ways to use Quad now, but I feel like in a year, it's gonna be a totally new set of things.
And it's gonna be so surprising if it's still these same things. Because I I think, like, we're seeing these giant trends happening right now.
Agents are running for longer. They're more autonomous. Very rarely am I running one agent at a time.
It's usually, like, a few agents or dozens or hundreds or thousands. And so, like, the form factor for that, it's gonna be really different than what came before. And I don't know what it's gonna be.
And I I think in a large part, it's gonna be up to the team to figure it out. And this is this is why I'm, like, so happy we run the team that the way that we do, where everyone just comes up with ideas and everyone is able to think about the product. Everyone talks to users all the time because I don't think these ideas are gonna come from us.
It's gonna come from the team. Totally. And from everyone in our community building with us.
The Hook
The bait, then the rug-pull.
Two Slack reactions. That was the reception when the Claude Code team first shared their agentic terminal tool internally — and one year later, the same two people who shipped that demo now manage teams running thousands of parallel agents from their phones.
How they asked for the click.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
OTHER LINKSAlso linked in the description.
