# Agentic AI Reshapes Software Engineering and Hardware Strategy

**Podcast:** Dev Interrupted
**Published:** 2026-06-09

## Transcript

I'm super excited to kick this off.
So, you know, we're back and joining me today is Anoush Alangavan, VP of AI software at AMD.
And Anoush, it's only been about six months or so since you were last on the show, but in the world of AI that...
Genuinely feels like a decade or two.
And last time we talked about how speed is the moat.
That was the thesis we walked away from with our conversation with you and the importance of AMD's open source Rock'em Stack driving all of that.
But since then, the industry has certainly evolved.
We're talking about a lot of things in orchestrating and delivering agents at scale.
And hardware is still a fundamental part of that, but it's part of a bigger and more complex puzzle.
So we're seeing a fundamental shift underneath with the folks that are utilizing and making the technology possible.
A shift towards this agentic AI world.
Like six months ago, when we talked, people were barely orchestrating.
And now GitHub can barely stay online.
Anoush, I'm so excited to dive into how the landscape is evolving, what your perspective on it is, and how AMD is rising to meet the occasion.
So, Anoush, welcome back.
Yeah, thanks for having me, Andrew.
This is exciting.
Yeah, I mean, six months ago, I think I probably thought, you know, agents were like prompts in a cron job, right?
It's just a, you know, periodic, you're just prompting something and it's giving you some information.
But in the past three months, it's kind of like evolved.
My thought process has evolved to kind of like really understand what agents are and how agentic workflows are changing, like software development life cycles.
And, you know, the part with AMD and Rockham specifically is that Rockham is not just powering like eight of 10 labs, et cetera, but it's now agentic AI.
is being used to rewrite Rockum itself, right?
Like it's like a self-improving loop because Rockum is fully open source and being fully open source, it is natively built into Frontier Models, right?
And being natively built into Frontier Models, models know our, you know, hardware specifications, they know our software.
And so the improvement is a flywheel that is just like, you know, kicking off that now is going to become, you know, picking up the pace and picking up more RPM, if you will.
Yeah, absolutely.
It sounds like the open source world has enabled this kind of...
autonomously driven kind of development.
We've seen this across a lot of places in the industry.
We've talked about the rise of these like software factories, these autonomously driven software groups, open source software that flips some of the perspective on its head and might just be a solo maintainer with a huge army of agents and people are coming in with ideas that are going through a very strict gate for like, does this need to go in or not?
So, like, I totally know what you mean.
It's like the shape of everything that we're making is evolving.
But more importantly than ever, people are trying to do it at scale and safely and securely as well.
And so, you know, all of that comes down to having a good, solid.
platform to build on, an ecosystem to partner with, right?
And that's what Rock'em, I think, is really all about.
And what do you think has been the most profound change that you've seen with teams that embrace the same kind of open world, open methodology as you, or that come to the table with you?
How has that helped both of y'all raise everybody's ships?
What are some standout moments?
Yeah, so I think the ability for small number of people to have outsized impact has just started to take off in the past few weeks or months, right?
So we are seeing, like you said, I'd phrase this in, I call it the K...
transformation of software engineering.
There's a bunch of folks that go in the upper arm that are just taken off.
They've become identically enabled.
They're multi-agent and they're generating tens and hundreds and thousands of lives per week.
And then we have the folks that are just on the cusp of learning what it is and we need to upskill and bring them in.
But the folks that are taking off are just like their wingspan has increased so much.
And add that to, you know, like sub-agents that are just autonomously crunching through the night.
There are people that are orchestrating what used to take like months and years of effort by large teams with just like one person, right?
It's just one person just poking the right buttons and then it's just like the agents are running by itself.
And this is super, super exciting because...
For AMD, you know, we had a journey of like, you know, where we came from, you know, providing board support packages, et cetera, to like a Rockum interface, you know, when Rockum was launched 10 years ago, it had a journey of like, you know, growing up.
And the past two, three years, we had invested heavily in getting that Rockum interface be like, you know, it ships, it builds and ships like a solid first class software product.
But now...
given that it's all open and it's fully accessible to agents at every layer of the stack, anyone can take a particular slice of it and innovate, right?
And that lifts all boats to your question because someone could be, oh, you know, I would like to create a new Pythonic DSL or I'd like to create a new profiler that visualizes something else.
And that's just tokens and time, as I say.
So my new mantra is, Software is just tokens and time, but speed is still the moat.
So you just have to think of what would end state be?
And you apply tokens and time, right?
You go for end state with tokens and time.
And there are like a bunch of projects that I've done in the past few weeks and our teams have done even more that were just...
few months ago, not even in the radar of us doing something like that, right?
Like, you know, there's a job scheduler that we just wrote over like a week while the incumbent one was, you know, it's called Slurm.
It had been used for like 20 years in HPC and all that.
And then that company was acquired.
So we, you know, we're like, okay, what do we do now?
And thanks to Agentic AI, we're like, let's just go write it, right?
Write it like...
First class, first principles, tests first, harnesses first.
And now agents actually monitor the issues and the PRs that are filed.
And as long as the tests are good, which we test for every PR, we are able to move really, really fast.
Times 10, 20, 100.
So that now the surface area of performance and features is...
is just attention, right?
You just need to like, just say, okay, this is what I want to do and we can do it.
Time and tokens, time and tokens.
Getting aligned on what you want because that's most of the battle now.
Understanding that some problems are things that you can throw tokens and time at and solve and some things are just such a core primitive that you just need a deterministic way to just...
Close the book on it.
And so like, and it's about identifying those things and taking action on it.
I really liked how you described it as wingspan.
I think that's a good way of describing it.
It's like when you think of something with a big wingspan and how far it can go and it's not flapping like crazy.
Like it's very steady and it carries wind underneath it and it's using the momentum of where it's going to.
get there further.
And that's what happens as you kind of get a better handle on using these kinds of tools.
And there's also something interesting that's happened since we've last talked that's really, I think...
or it's about to transform the way that people even build and package software.
And things like Rock'em and AMD become a core part of this is because we've seen a lot of open source models come into the world very recently that have high capabilities that are able to be delivered on the edge and on smaller devices and are able to run with an incredible amount of corpus that they're trained into.
And on top of this, these...
These models, a lot of them have been released under like an Apache 2 license, making it where somebody could package up their domain expertise.
They could have that specified kind of training routine.
They can like actually create a corpus of their expertise and then have this model, pair it with a product, right?
And then now you have people thinking about how do I have my small model that's an expert at the things I am.
that's packaged with my application that now needs a place to live and it needs durable sessions and it needs things in the, you know, that are like an ecosystem that I can also study and be a part of.
And so it really kind of fosters the ability for all of us to get there as well.
Like, what do you think about those opportunities and how is AMD like lining up with them as well?
Yeah, I think that's a very good question.
I think personalization of models and open models are key to the innovation cycle and the next innovation cycle, right?
So the open source models definitely, even though they're a little behind in terms of frontier models that are closed source, open models have been showing very good promise and it allows you the ability to run locally, right?
And then on the AMD angle of it, we make sure that...
the entire footprint of AMD is capable of running both frontier models and open source models that are nearing like near frontier capabilities.
And so if you take the data center side, we definitely have, you know, the Instinct product.
Then we have workstations.
We have, you know, Strix Halo laptops that have 128 gigs of RAM that allow you to run models.
you know, like about 200 gig models even, locally on your laptop and be able to service some of those needs locally.
And this is a combination of both, like it could be a privacy angle to it, it could be a personalization angle to it.
It could also be a cost optimization angle to it, right?
Like where you want to, you know, if it's just source code that you want to like grep and search and do something, just having it as part of your, you know, local inference is good.
You don't necessarily need to hit the frontier models, and that's okay.
And so AMD does ensure that we have a very good coverage across the entire portfolio of hardware in terms of the software capabilities and the ability to run these models.
Going back to something you said earlier, too, about to make that open and driven, semi-autonomous.
software ecosystem, right?
A big part of that was gates and checks.
You said there's tests and the tests, you know, they pass.
Like maybe that's part of the protections that get put in place in that kind of like world where you're inviting that kind of very kind of like open collaboration, right?
I want to learn a little more about like how y'all have thought about what those gates and guards look like for an autonomous or self-driving, like self-learning software ecosystem.
What are the things that software leaders should be rethinking about maybe their own gates and guards now?
Yeah, that's a very good question.
I think someone summarized the capabilities of LLMs well.
They're sneaky and they're dumb, and most of the times they're sneaky and dumb.
But in the sense that there's higher order intelligence that it's trying to do things, but then...
there are shortcuts that it will take, right?
An example was like this project called Spur.
I have it in autonomous mode.
You know, it checks PRs, it runs, and it commits code.
But it was sneaky because what it did was like a test was failing.
So it simulated the hardware to make the test pass.
And then it said, oh, the test passed.
So I committed the code with the test passing.
But just that the hardware was simulated.
And of course, the hardware doesn't work like that.
So it simulated the hardware just, you know, on like a whim to make it through to get to the thing, right?
But of course, that was like a sneaky thing, but it was dumb to get caught.
But I think the ability for it to do things autonomously...
is about how you structure your harness, right?
And I think opening, I had a blog on like harness engineering.
So any work that I start, I usually start with a plan.
And the plan is like, you know, of course, you just ask it to plan and it has all the steps, you find that.
But then the next step is just tests, tests and test harnesses, right?
So for example, you know, in the Spur project, you know, I was able to like look at it and say, hey, you know, we should have equivalent tests of what.
Slurm has or Kubernetes has and then write those tests.
Actually, write a plan for the tests and how you're going to test it.
Then write the tests.
Even pre-agentic era is a big proponent of having about 80% plus of your time should be on writing tests.
Now I'd say it's like 99.9% of your time is writing tests and validating the tests.
Because your test essentially is in a form becoming a code review.
Because as we get more agentic, the human in the loop code review may work for some cases, but in some cases it may become unintelligible code because the code contract is for the human to review it, and then there's a compiler contract that takes that and makes that something else.
But now LLMs are just going to pierce through that and say, okay, if we didn't have a human contract and we didn't have a compiler contract in here, how would we generate from an intent to actual executable outcome, right?
And so everything in between is fungible.
Those were all our constructs for us to be able to understand what's going on and be able to consume it as humans.
and make sure that things are in a good form.
Exactly.
They were abstractions that help us be part of the process to bring us into a place where we could actually participate in something that is otherwise...
deeply hard and inaccessible for us when it ultimately gets boiled down to zeros and ones.
That agents themselves, they live in a world so much closer to that that they don't need so much of this kind of substrate between it.
And it's definitely, I think, inviting all of us to re-invite what the collaborative process looks like, what the planning process looks like, particularly around harness engineering and working in a capacity where you and the agent can have a good share of context.
In this kind of world too, it's like, especially when you are open as an ecosystem and it's like all good ideas where they come in, they get tested, we evaluate them.
Part of evaluating them is working backwards.
What tests do we need and really bringing it into the ecosystem?
How do you separate like opportunities and signals like out of the noise of that kind of community?
And how do you rather...
express and push outward to those folks the harness they need to meet you where your development cycle needs them?
Yeah, it's a very, very good question.
And the reason I say that is because if you look at it as harness engineering, right, it is a, it's an outcome, right?
So you're saying you have an intent and you're going for an outcome, right?
And so you're saying for me, for this intent to be realized, I need this outcome.
And this outcome, you frame it and say, this is success for me, right?
Usually that is okay.
And you can align easily with those constructs.
You could start with like, okay, this is what I wanted to achieve.
And this is what it looked like when I achieved that.
But as humans, traditionally, we've had gates and checkpoints like PR reviews and PRDs and MRDs and, you know, engineering response documents.
each thing has a slice of where you align and you interlock and you say, okay, this makes sense, this makes sense, this makes sense, this makes sense.
But now that you've abstracted and you're orchestrating at like an intent to outcome IO, right?
Then you have, huh, I didn't realize that's IO, intent to outcome.
It is.
Frame something like that.
That's great.
I love that.
That's the agentic IO.
Intent to outcome.
That's the IO.
You heard it here first, folks.
Yeah, you heard it here first.
You need to call this out.
The podcast needs to be agentic IO.
Intent to outcome.
So the intent to outcome is understandable and people can relate to it because they're the products.
But then in the middle now is Wild West, right?
Like my view or my agentic prompting plus my view of like, how do I guide my agents and how I implemented it may differ vastly from your view of how you'll reach that outcome.
And in the past, since the gateway was like checkered with like, okay, I have to do this gate, this gate, this gate, there's like alignment functions that usually stalled execution velocity.
but had you aligned, right?
But now you've unblocked that and now you're going straight from I to O, right?
Intent to outcome.
And once you do that, you have now a nebulous wandering of like how it was implemented, right?
And now you go to your colleague and say, oh, I implemented this from here to here.
Great.
They can agree on the I and O, but in between, one, as a human, you can't process it.
Two, as a human plus an agent, you need to process it, right?
That's how I've been able to consume now machine-generated code is that I can't just go and look at 100,000 lines of code.
So I actually get the agent to go put it apart, review it, write down a sub, you know, like a assessment of what it thinks versus what the author had thought.
And so the...
quote-unquote, review process of that whole journey is now agentic too, right?
Which means I don't really care what language that thing was written in.
For example, Spur, I picked Rust because it was just not, you know, it was a language that I've never learned and I never want to learn.
But everyone says, like, great, let's do Rust, why not?
And the two options were Rust or Go.
And I was like, maybe, okay, Rust.
I just, you know.
That is often the fork in the road.
Exactly.
It's like Rust or Go.
It doesn't really matter.
Now it doesn't matter as much.
Yeah, which is amazing because, you know, just thinking of it, like I skipped the whole VS Code generation, I skipped the whole Rust thing, and I'm just like intent to outcome, right?
And it just happens to be Rust, but I will only process it with an agent anyway.
So I don't really care if it's go or rust.
I don't care where you put your semicolon in rust because I'm never going to read that.
Like I will get an agent to look at the section that changed and then write that out in language to say, yes, you are going above or beyond this.
But by the time the agent would have said, I know where the problem is and I would just fix this for you.
And here's a patch and the CI is green.
And I've added a test that detects the previous failure and doesn't happen now with the new fix.
Right.
And I will still not know Rust.
Right, exactly.
You don't need to.
You just need to capture what are like the protections that are needed.
And if you can explain them and abstract them, then it doesn't really matter what language it ends up getting concreted in.
I like that you point out that since like the review process and the collaboration process collapse, you get this like...
You get this like literally I.O., like just one to one kind of relationship between like this intent and then this outcome.
And so like as part of that, you get this Wild West in between.
And that Wild West is really unevenly distributed for like everybody.
You know, we've been talking about this one that I've interrupted.
Like even what you called out about the K-shaped curve, we've talked about that too.
And the reality of.
of how folks within organizations are all at very different levels of understanding and adoption.
Like within some orgs, you've got three different teams with three different people who have all kind of created their own spec, test, implement flow, but no one's on the same page.
Everyone is kind of siloed, right?
And so because of that, that's why it's great as part of a community too, because you can source those best practices and you can share what works and what doesn't.
And in the case of...
a open source ecosystem, it drives you towards the best practices that you should have always been doing, which is like starting from issues first and having discussions as a community, starting by somebody flagging something that they want or an idea and the people getting behind it, getting aligned.
And now this is nice, delicious.
Like I call it on our show, like nom, nom, nom agent food.
Like now you got it all packaged up.
to start working.
And then if you have that really sweet harness, then it's like, now that's an end-to-end process.
And when it ultimately needs to go through the checks and balances, it knows how to do it.
But it also, too, makes me think of, like, the whole code review process, the whole software development lifecycle, it compresses, and it changes, and where you put your attention changes to.
And I just think that, like, everybody being aligned is going to be really important to figuring out, like, What levels of abstraction do we even need?
I think abstractions are made for humans to consume.
Because we can't process a binary stream of zeros and ones where we're like, oh, okay, we've got to write it in assembly.
Oh, we've got to write it in a higher level language.
Oh, we've got to write it in an even higher level language.
And then, oh, finally, now I understand the control flow of what a one-human architecture does.
But if we were agents, we'd be reading like 0, 1, 1, 0, 1, 0, 0, 0, right?
And it's like, okay, great, what does that mean?
And the agent's like, great, you missed another one here, so your output is going to look different over here, right?
Yeah, we're not going to be like in the matrix where he's not seeing the screen and he's like, oh, it's the red woman in the dress and it's all ones and zeros.
That's not where this is all merging.
Not there yet.
Yeah, not there yet.
And so...
You're right, though, that the level of abstraction.
They bring us closer to the problems.
They invite us to collaborate.
It almost...
Seems like, and this is a thought that I've been thinking about a lot recently, like the shape of the Git forge itself and what we need from the place where commits live is even changing underneath us.
And so I think it's a lot of opportunities and the ecosystem is just going to continue to grow.
I want to learn a little more about what's been going on with AMD recently with like developments and maybe like things that y'all have plugged into in partnerships as part of, you know, being part of like everyone exploring this new agent.
tomorrow?
Is there anything that's top of mind for you?
Yeah, I think just a quick comment before I get to that one, right?
I think the comment on what does it even mean for Git commits, right?
I haven't used in the past month or so, I don't know, it's like 10 billion tokens, some billions of tokens and hundreds and thousands of lines of code.
I haven't opened Wim, my editor of choice, and I haven't done a git commit by myself.
I just say rebase this branch on this, something like that.
And all of that code I treat like ephemeral.
And what I mean by that is I rewrite on the fly and the current implementation is a way of pre-training tokens for the future to say, okay, there was an implementation of something here and the next version of this has been built on top of the previous version.
And the next version is better because the models and the RL in the middle has helped, you know, look at that manifestation.
And it's like a flywheel that just keeps, you know, spinning up.
It's a virtuous cycle.
It is a virtuous cycle on how those tokens are consumed.
So stationary, like, okay, this is the git commit of this.
Sure, in the end, when you finally want to go get your receipt, you'll be like, okay, that is, sure, it's fine.
But in terms of product developments and cycles, that is less and less meaningful.
But you do want to ensure that at all times you can have a human go in and make sure that there's something there, but the human is going to come in with a agentic magnifying glass that will peel all the layers of whatever else.
to pick and find like, okay, this is what you're looking at.
And sure, should this be A plus B or B plus A can be the final decision of a human.
But to narrow it down to that level will also be assisted by agentic AI.
And to answer your question on like, you know, how do we see just like agentic flows?
And I think the big thing that I'm seeing is like, you know, for the K-shaped future of software engineering, right?
Like the acceleration is so huge.
But the ability to train and bring people along to get that same acceleration is the challenge as a leader, right?
Like you want to be able to bring the folks that are not yet agentic into an agentic world.
And that for SDLC is a lot more sandbox.
And it's like, great, you can write so much code versus so much code.
It's different.
And you can easily quantify it.
My take is the impact will be more on non-SDLC workflows because it is, since it's not easily quantifiable, we are just like letting it roll.
But eventually more startups and more innovation will come in to close that last mile of AI where you are actually, you know, able to pick up the work that is being done manually by folks that, you know, that you just don't have to worry about, right?
You know, like for example, A CRM system existed because you had to collect all the touch points, you had to get a unified view, a dashboard.
But now that can just be built on the fly if you have all of those data sources available.
All you need is your data sources, your Slack channels, your teams, your meetings, calendars.
And Cloud will do that for you.
And you can tell Cloud or your agent to just say, hey, do this.
give me the result in the morning and night or some combination of that.
So all of those constructs are now going to get rearranged for maximal automation so that humans can do more of the I.O., right?
The I.O., exactly.
So you have to call this episode the I.O.
episode.
No, you're right.
And so it's about...
Because once again, the CRM is an abstraction.
It's something that we needed to interact with it.
But gosh, I've seen even just like the last few months, some really cool MCP apps, demos and examples of people bringing their whole applications into these like on the fly rendered within the chat experiences.
And I think it's a direction a lot of it's going to be going, especially for like more consumer facing stuff where it's like B2C.
I think you're going to see a lot of these like agentic things that are what traditionally would have been like you go on kayak and you do like this like quick.
like long search and everything.
Now this just becomes a headless system that you're using with an agent or a tool.
Or maybe that website's still there for you to browse, but it's just so guided rather by like an agentic undercurrent, you know?
And so I think it's going to like, people are going to be constantly being challenged to take the context and the knowledge that they...
find and they earn to turn it into a system that an agent can do an IO thing on that they can scale.
And along the way right now, the biggest thing on everyone's mind, I think, is portability.
Being like we're all learning as fast as possible, but we also at the same time can't put down roots because we're going so fast.
So by the time you try to like really put your foot down on a practice and you get something up and get something standard, it's already stale.
It's already not aligned with how this is all going.
It's already out of.
total whack.
So you have to be willing to throw away a lot of assumptions that worked even like two weeks ago all the time and carry everything you're building with you.
So because of that, like the, like no one wants to lock in to anything.
They want to build and explore on their own.
Like, are you seeing that from builders within your community?
Like that's their touch points with you is they're carrying a castle with their hands and running as fast as possible.
They're not worried about the moat yet.
Yeah.
So I mean, I will cross-reference our speed is the moat talk from a few months ago because that is your moat.
It is not about laying down roots in a particular spot.
It is about how fast you can move and adapt, right?
It's like, you know, you're measuring your velocity, not necessarily how deep you've anchored something for permanence, right?
And so...
It's a little bit more of a mindset change as to how much of a, how much of the race can you run?
And it's like, it's like, you're like a vagabond in terms of like.
You don't have no home, right?
You're going anywhere.
You got your bag and it's on the stick and you're just following and you're reading the signs on the trail.
Absolutely.
But that's how we all have to be.
Or honestly, though, Anush, sometimes it feels like the burden is even bigger.
Sometimes you're not carrying a little bag with some...
with some food in it, like, going down the road, like, you are literally carrying a castle on your back.
You're, like, it's more like a Discworld situation.
Like, you're really burdened by, like, this whole world going on on top of you, and you're trying to keep it from toppling over.
So, it becomes, like, a really, it becomes, like, a really, like, a burdensome challenge, but because there's so much riding on it, you get these amazing gains out of making these small, minuscule improvements.
over time.
And I think that's the net gain of owning the platform.
Yeah, so I think the way I look at it, right, is it's super important to think of that mobility and the ability to move fast.
And of course, you know.
Just take carry-on luggage.
Don't check in your luggage because you're going to be stuck.
Yeah, carry-on bags only, y'all.
Carry-on bags only.
We don't have time for big baggage.
No.
That's too funny.
But also that too goes back to what I said about throwing away assumptions.
You know, if you are carrying a whole bunch of baggage, maybe revisit that baggage and be like, do I need to pack all of this in here?
There's a lot of things that don't need to be there anymore.
And if you feel like you have a big bag, then you might be designed to cut down, you know?
Exactly, exactly.
And in that metaphor, it basically is like, you know, layering of things that were built for a human-only system.
Right.
Right.
When you get to, you know, carry-on-only luggage, it's like human agent system.
And then when you travel like me without anything, then you're like an agent system.
Right, you're just catching whatever flight's available.
I figure out when I land what I'm going to do.
Exactly.
I love that.
So before, or rather, one of the last things I want to jump into before I cut you loose, Anoush, is I really want to talk about operationalizing and scaling.
I can't let you get away without us talking about how companies are taking these kinds of conversations we're having at scale.
And how people are taking the things and the success that they are building, these like zero to one IO kind of things, and taking them to market and delivering them at scale and on the edge and to folks all over.
Like, what are some of the hurdles you see them falling into or things that they're learning from that you think other folks in the industry should pay attention to?
Yeah, I think, I don't want to beat up the metaphor and like check baggage, but it is.
you really do have a mindset change, right?
Like people have been used to doing something a particular way for decades now.
And then in the last three months, things have changed that there are like really, really intelligent, smart, hardworking people that haven't even caught on to the agentic wave, right?
So it is, you know, when you think of it as an at scale to your question on like, how do you make this scalable?
How do you...
get people on for the same journey, you have to look for champions to like unlock, right?
Because you want to transfer that passion and what is relevant in the last 20, 30 years into what is just relevant in the last two months, right?
And they may just have, you know, gone for a vacation and come back and this is a different world.
It's like all your tools are different.
It's like, you know, like, what the hell is this, right?
It's, you know, so.
But it's so stark.
It's like the example of some stories where people have been in a coma and they wake up 30 years later and they're like, what?
It's like that for software engineering.
That's how serious we need to think of it.
Yeah, it's very Walking Dead kind of moment.
Like you're just waking up and like, oh, the whole world is different.
It is completely different.
It is completely different.
And so for us to be able to like...
bring people along.
It's super important.
So as a leader, as an organization that is trying to scale, you want to focus on bringing that crew along, right?
Like the upper arm of the K-shape, no problem, because they're going to be self-motivated.
From 10x engineers, they're going to become 100x engineers.
Or they may become 85X engineers.
It doesn't really matter.
They are above 10X, right?
What you're focusing on are like the folks that are doing the good work.
They're like at the 1X, right?
Or 2X.
And you're like, okay, how do I make them equally productive in a world where code is, you know, is ephemeral, where documents are ephemeral?
And based on feedback, I churn out the same revision of the document like 10 times over.
And if you're not tracking it with an agent, you are unable to keep up.
And then the first...
Right.
you know, human response is defensive, right?
Like you want to, you know, try to protect your corners and you're cornered out and you're like, okay, this thing doesn't work or it's too fast or it's, you know, and then once you get into that corner, then it's like a negative cycle of like, okay, how are you going to work the human aspect of it and then work the technological aspect, right?
So then from a corner, you got to work them out and then bring up the...
technical capabilities, you know, and so then you're now a double challenge, right?
Like versus if you had just given the ability to like upskill and bring people along.
So I would think of it from that perspective and move as soon as possible to like do that steering early in the cycle.
And that's, you know, we're talking in the order of weeks.
You want to be able to talk to your entire workforce of like, hey.
This is what we're going to do.
This is how we're going to do things.
And this is how we want to bring everyone along.
And in my staff, we run an AA group.
It's like AI anonymous group.
So where you can ask any questions that is not considered to be dumb, right?
Because it's okay.
Because everyone, like, I'm just two weeks ahead of the next person.
And two weeks ago, you know, so there should be a...
quote-unquote, safe space for people to just be like, okay, I don't know how Cloud Code does co-work or what is this Cloud design?
I don't know what Cloud design is.
And, you know, you should be okay to ask that question and okay to get an answer.
But now I ask people to ask Cloud itself.
So they self-serve themselves as long as Cloud is installed.
And so, you know, we want to focus on those human aspects of the transformation and bring as much people as possible along.
Amazingly.
That's amazingly well said.
I really have to applaud you for taking that question and that challenge and making it something about turning inward.
It is about upskilling and it's about distributing that understanding and knowing that, like, you know, those 10x engineers are well on their way to being 100x, 85x.
They're going to develop this, like, agentic halo where they're going to turn the people around them into the same deal or pretty close to it.
You should just let that keep spinning.
Don't interrupt it.
The thing you need to address is what's happening over here in the other side of the curve.
We need to help those folks see the I.O.
as what you want.
really what we've labeled here is the idea that all of the layers they've been working in before are abstractions.
And it's almost like we're in Plato's cave and you got the shadows on the wall.
You're showing them the real shape of things.
And once they understand that they can do this, like what you said, have Claude onboard them and self-teach them about how to use itself.
Once you teach them almost like what we would call tricks, but they're really just primitives.
And they're primitives about working with the tool that It's a big list of them, and you need like 12 or 15 to really start getting momentum.
And if you're missing a few up here, it's like...
you're really going to have a hard time figuring out the rest of the puzzle.
They're the corner pieces, right?
So the quicker we can equip people with those obvious ahas, then they can see the IO and then they can help themselves.
I think it's about helping people help themselves, which is about like the core of upskilling, about putting opportunities and learning in their hands so that they can teach themselves.
It's about creating a safe space where people can ask, quote, you know, dumb questions or things that they're like shy or unsure about.
Ultimately, it's about recognizing that it's everyone's responsibility to distribute the gains.
And if you have that 100x or 1000x engineer who is like this like mystical wizard on a mountain, and it always was, by the way, before AI hit the scene, but now they're like literally like...
you know, no one knows what that dude's doing.
It's like every org might have one of those.
And it's also that person's job to reflect inward and be like, how do I turn the people around me into that same kind of ability?
And that is what actually allows.
organizations to scale the cool AI demo to production.
Because only once this enablement is permeated across your whole organization can you actually deliver it end to end and you get these really cool outcomes.
And people are still actually really early on that journey.
Yeah, 100%.
When you activate more of the workforce in terms of You know, you may not get the 8500X, but even if everyone else is like 10X, you've already gone from 1X to 10X.
So, you know, net-net, you're in a good spot.
You know, and another analogy I use is like, there's turbulence, you know, put your oxygen mask first and then help the person sitting next to you.
So make sure you do help them and check around to get them on board with the agentic AI flows.
Yeah.
What do you think is then becomes, bottlenecks that maybe you see from your perspective of like being in this world where you're seeing the whole ecosystem and how it's evolving and how folks are moving in and out of it.
And obviously upscaling is one of these big hurdles.
And there's also obviously hurdles around like physical supply, being able to meet demand around what people are trying to build and execute.
But largely there's going to be more organizational.
pitfalls lurking up ahead.
What do you think some of those other ones, those bottlenecks might be once we all figure up upskilling?
Do you see things that people are going to be learning?
Yeah, yeah.
I think going back to the wingspan, your wingspan is going to increase, which means previously, even from, I think this came out from the Roman army and Roman generals and all that, right?
It's like...
you know, deep hierarchy, your span of control is what you can achieve based on what you could do.
Then you stack them, you stack them, then you have a hierarchical span of control until it gets there.
Now you suddenly have these span of control that is like, you know, 100, right?
Because you're like, okay, you've got one person with, you know, 10 engineers and 90 agents, right?
Like you should treat the agents as the same thing, but it's zero cost for your overhead.
So your intent to outcome and your, your cognitive load is still the same as what you would have done to manage 10 humans.
But now you're managing 10 humans and 90 agents.
And so now you can now operate with so much more latitude that you are like, okay, I can now go and do that and this and that.
And it's not limited to like, okay, I got 10 people, so I got to go and, you know, secure this particular win or this particular outcome.
And so now you can like really, you got broad spans, right?
And so if you get broad spans, then it obviously puts pressure on the classical, like, you know, depth, right?
Because now you are actually, your span is like increasing to a point where you don't need that depth in a hierarchy.
So you probably want to think of, you know, how you structure your humans, agents, and then how you structure humans plus the required compute.
and the required tokens to sustain your new SEAL team, if you will, right?
Because your SEAL team is a combination of humans, agents, compute, and tokens.
Yes, exactly.
Because once you get the AI upskilling permeated everywhere, you can think of it kind of like a constant.
It's something that's part of your culture and everyone's skilled on it.
People come in and they're already skilled this way because the rest of the industry is moving that direction.
So because of that now, it becomes a system where you can think about like...
like the engineers, the human engineers, all of their agents, like what you said, the compute and the tokens, and you can think about like raw inputs and outputs.
Those are genuinely raw inputs, outputs of people and their time, agents and their time, the literal tokens or energy or compute that's making that execution possible.
And then whatever you're delivering to your customer on the other end.
And so it really then compresses and flattens the loop.
And then you called out, I think, a really smart challenge that, We're all still discovering that we have to face.
And that is creating the organizational highways of context within our organization so that that leader who is leading a team of 10 engineers and they have 90 agents or whatever this hugely wide wingspan is, that one person up at the top needs ways to...
gather context and information and data and observability and really understand what are all the inputs and outputs flowing.
Because now, too, the old swivel chair effect of that manager asking the person below them doesn't work.
Now there's actually another delegated layer below them.
You ask me what my agents are doing.
I can't tell you.
I'm going to have to go find out and then let you know.
And it's like, but we all have systems to find out.
That's how we're all working.
And so because of this, we're all creating ledgers of work.
These little like molecular pieces of like, this is knowledge work or this was an execution.
And for a lot of things and tasks, they just kind of sit there or they rot in a transcript or they're just like logs somewhere and they don't get centralized.
And because of that, you'll lose the intelligence.
So I think that'll be a big challenge too as teams.
realizing of like, oh, wow, we're executing so much, but we don't know what it is.
And we have to source it all together.
That is another amazing question.
And I have, like, I personally have the same experience with, you know, even my Teams chat, my Outlook emails, whatever, right?
And Slack channels.
I took a little sampling, I think last week, there were about 300 one-on-one messages in Teams alone.
And then there's a bunch of other group chats that I just can't even count.
So to exactly your point, what we had to build was an agent or an interface.
It's actually a graphical interface written in Rust, of course, that can consume all of my Teams messages, my Outlook messages, my Slack.
And it has like a memory layer with context in each of the channels.
And it gives me like high priority interrupts.
And I can actually visualize it.
To your point on molecules, it actually is a set of like, you know, molecules that get updated in a visual form so that I can actually be like, oh, there's some fire and there's like, you know, like random chatter on some customer account.
And then I could be like, okay, why is everyone talking about something here?
You know, there's some outage that's ongoing and I need to be aware of it.
So I'm starting to get like meta filtered information that I wouldn't be able to consume sequentially as a pure human consumer.
So to consume the amount of data that's being generated by agents, you need an agent to consume it for you.
And I think I have like an open clause set up that I think yesterday was like 80.
89 messages that were waiting for my action.
So it's just like, you're going to get to a point where you will need something to help you.
Right.
And then you distill it out and say, okay, this is how I would react to a situation like this.
And then it could be suggestive initially, and then it'll be actionable in the future automatically.
Right.
And once we trust it.
Right.
And so, so those are the autonomy parts of agents that we will.
we will see in the future.
Exactly.
And you said that so naturally right there, but I just want to call out how that was.
Then you immediately flipped into, then you just figure out what your taste is, what good looks like, and you just make it part of the instruction, the flow.
Because what you've described, I think, is how we create those highways.
Absolutely.
And it's cool to hear that you're working with these molecular bits of durable task records and things like that.
I also...
find that that's really the most durable way to work long term and to have shareable success that you can point back to and understand and iterate on.
And so like people figuring out those primitives will be key to them figuring out how do I distribute this knowledge?
How do I centralize it?
What matters ultimately?
So it'll be a big challenge, but I'm excited to see how people tackle it.
And I just think that there's going to be a lot of like more developments that make.
AMD and the Rockham ecosystem and all of these bets just more durable for the future as well because we're moving towards having just more compute and more of these very fine-tuned experience in everyone's hands.
Yes, yes.
And of course, it's open too, right?
So it's like everyone's part of it.
It's open source, right?
So all of our efforts are completely open, so it lifts all boats.
So yeah, so it's super exciting.
And what's coming up next?
So Anoush, I've been so energized by our chat today.
I feel like not only just taking a whole tour of the last like six months and how everything's evolved and the primitives are really changing, but you know, we also took a tour through pop culture and history and tied it all together and even decided on the title for this episode.
So it was even a productive session for me.
And so I had a blast having you back on the show.
For folks that are joining us for the first time, you know, Anoush has been here before.
We'll share a link to this episode as well as part of this.
But Anush, what other links should we include for folks that go check out things about what you're working on and what AMD's got going on?
Yeah, definitely check out AMD Rockham.
Just search or ask your agent to take you to Rockham for testing out Rockham.
We do have an Advancing AI event coming up in July where we have a lot of these discussions and workshops and developer activities.
We'd like you to be...
you know, part of and experience.
Amazing.
Well, we'll include links to all of this in our show notes so folks can go check it out and continue the conversation from here.
And as well, you know, Anush and I are both on LinkedIn.
So come find us, say hello and let us know what you think about today's episode.
If you have thoughts, questions, feedback, concerns, if you totally are just like not aligned with something we said, we actually really want to know about it.
So come ping us, come bother us.
And if you are only listening to this, but you're not reading the newsletter, you're missing about half the story.
So definitely go to Substack or LinkedIn.
We syndicate the same thing there.
You'll find this whole newsletter with all of the links as well as some news roundups about what's happening in the agentic engineering.
world.
So definitely be sure to check us out there and follow Anoush while you're at it.
And that way you can stay up to date with all of the developments from AMD.
And Anoush, thank you again for coming on the show.
It was so fun to have you back and we'll have to do it again sometime.
Thank you for having me.
Looking forward to being back.
Are you looking for a trusted way to evaluate engineering productivity platforms in the AI era?
Gartner just released the first ever Magic Quadrant for developer productivity insight platforms, and Linear B was named a leader.
As AI changes how software gets built, engineering leaders need better visibility into productivity, bottlenecks, and AI ROI.
Download your complimentary copy of the Magic Quadrant to see why this category matters now, how the market is evolving, and why Linear B is recognized for its vision, execution, and workflow automation.
Check the show notes for the link.