This started as a talk I gave internally to a group of technology leaders. I’ve adapted it here, stripping out the company-specific material, because the core ideas apply well beyond any one organization.

I want to throw out some ideas about what I think is changing in our industry. What I’m going to describe is one of the most rapidly evolving, most dynamic changes I have ever seen in a twenty-plus-year career in technology. I believe there are things changing right now that will fundamentally redefine how we practice our craft.

Where we are

Let’s bookmark where we are. Agents are real. I’ve watched one go from nothing – zero, no code, no design – to a working alpha with real users making real decisions on it, in about five weeks. A year ago, this was an idea. Now there are production agents running.

Agentification is the next major milestone our industry is going through.

I’m old enough to say this: there was a time before the web and a time after. A time before mobile and after. A time before the cloud and after. And now, a time before AI and agents and after.

I think this is going to be the most transformative of all of those.

You have to acknowledge one paradox of where we are: we are building the best practices before they exist.

We’ve been here before. Those of us who lived through the cloud transformation remember being ahead of the industry, figuring out how this ephemeral compute stuff works, how to make it all function. There weren’t patterns the industry had settled on. That’s where we are today. There are no clear patterns for how agentification happens. We’re going to build those patterns and learn alongside the industry.

That’s okay. Just be aware of where you are. It’s fine to be out ahead of the curve; you just have to always know when you’re there, because it’s a risky spot. You don’t want to be too far out.

Getting philosophical: software is becoming liquid

I want to get a little philosophical.

For the last two months, I’ve pushed myself into a level of AI engagement that is probably unhealthy long-term, honestly. If you ask my family, they would agree. But what I’ve been trying to do is really wrap my head around the core concepts that I think change how we do what we do.

Connect this back to other transformations. When we adopted a mobile world, we all knew we needed to be mobile users to lead it. Can anybody build a great mobile app if they’ve never used a mobile phone? Obviously not. So to lead through AI agentification, we have to be really close to it. I’ve been pushing myself hard to do that, because as you build experience, it gets harder to refactor how you think.

Here’s something I’ve been thinking a lot about: what is the cost of being wrong? And how do we fold that into how we create things?

Step back for a moment and think about how we do our craft. Say we’re building software. We spend time on discovery. We create stories. We have designers go off and make wireframes. We do all kinds of things to make sure that, when we actually get to the point of building, we know we’re doing the right thing.

Why? Because the act of building software has been incredibly expensive. The last twenty years of my career have been about figuring out how to effectively turn ideas into working software and how to make sure that, when we do, we’re not wrong – that we’re producing valuable capability. That’s what technology teams around the world have been focused on. The teams that do it well do these things better than the teams that don’t.

Here’s how I’ve come to think about it: software has historically been a solid. It’s chiseling something out of granite. We have our ideas, we sit down, it’s hard work, it’s challenging, and we chisel it out of granite.

I think that’s changing. I first heard this from somebody online and it didn’t land for me at first – I thought, that doesn’t make sense. But the more I thought about it, the more I thought it was spot on. The assertion was: software is becoming liquid.

We’ve operated for two decades in a world where software is an incredibly difficult solid to shape. With AI and agentic development – automatic programming – software is becoming malleable. If you’ve worked with agents on software, you’ve had the experience of thinking: I can refactor this code faster than it would have taken me to do all the guardrail work to make sure I didn’t make the wrong decision in the first place.

When the economics of what you do change that profoundly, you have to question everything.

Every paradigm built on “software is expensive” needs re-examination

Go back further. Most of us spent the early parts of our careers in agile flows. Before that, everybody did waterfall. Why? Were they just not as smart? No – they were operating under a different set of assertions. If you made a mistake writing C code, it was really difficult to unwind. You’d take months to refactor a mistake in your domain model that showed up in C code.

Then we got Python, PHP, interpreted environments, continuous integration. The paradigm changed. Suddenly: what if I’m wrong? Fine, I’ll refactor. Refactoring Python is cheaper than refactoring C. That’s just a fact.

So here comes agile. We can do this differently. We can be more responsive.

The cloud is the second part of that story. The cloud says we can do the same thing with hardware – we don’t have to worry about where we put the server. The cost of being wrong, if I put a server in the wrong data center, is not easy to undo. But in the cloud, that’s a couple of commands.

We are in that same spot again.

AI is transforming the cost of creating software in a way that should make us question every single process we have that is fundamentally built on the assertion that creating software is expensive.

I’d argue that maybe proof of concept doesn’t make sense anymore. What we used to call a proof of concept is now discovery. And how do you do discovery? I think you do it in code. Your discovery process is entirely in code. Do you then throw the code away? No. Why would I? It’s liquid. I bend it, move it around, get it where I want it.

The act of discovering through creating changes things pretty fundamentally. That paradigm is going to take us a while to absorb. I really want you to think about what you have in your world that makes assertions that building this stuff is extremely expensive. And when I say “cost,” don’t just think dollars – think organizational cost.

That’s assertion one: software is becoming liquid.

Managers belong in the code

Here’s my second assertion. If you’re a people leader, this one is for you.

I used to have a very firm belief. When I saw a people leader – a director or a manager – in code, that was a warning sign. Almost always, when I saw a director or manager in code, they were probably avoiding something harder that they were supposed to be doing. “Oh, you’re working on the actual software? I bet you have a personnel problem you’re not dealing with.”

I don’t think that’s true anymore. Agentic engineering changes that fundamentally.

The issue historically was a simple one of context window. As a manager, you couldn’t truly know the codebase because it was too complicated. It was a solid asset your craftspeople were working on. You had to focus on the people systems. You just couldn’t hold both of those things in your head and be effective.

Agents change that paradigm entirely. There is no reason, as a director or a manager, why you shouldn’t be talking to an agent and asking about the quality of the asset you’re accountable for. And as a people leader, you are accountable for the assets your people create. So why aren’t you having that conversation?

Why would I ever start a conversation with an engineer with, “how long do you think that’ll take?” I should have had that conversation with Claude Code first – looked at the source, asked: is this a big refactor? If we went this direction, how would that look?

This flips even further on its head when we think about agentification, because increasingly we’re going to be creating software not for people to use, but for agents to use. Think about how that works. You work with an agent to create the software. Another agent uses it. The agent using it gives you feedback on how it’s working. You take that feedback back to the coding agent and ask it to iterate.

What are you in that loop? I don’t know – a product manager, I guess.

I’m doing this today on multiple projects at home – using agents to give each other feedback. This speed and paradigm shift is foundational to how we have to adjust our thinking.

Rethinking velocity

The last thing I want you to really think about: as an industry, we need a step-function change in how we think about velocity.

How long is something going to take? I’d argue every paradigm you have for answering that question is broken now. The cost understanding is broken. The complexity understanding is broken. It’s all broken.

The only way to truly gauge it is through the second thing I mentioned – getting closer to the asset you’re accountable for, getting closer to the code and the product.

Just like mobile – where you couldn’t understand how to build an app until you’d experienced one – you can’t understand agentic transformation until you’ve experienced it firsthand.

Don’t be scared to go close to the code. Don’t be scared to ask your team, “Hey, how do I get that code out of Git? I’d like to look at it and do some analysis.”

These are superpowers. Every single one of us can put a cape on. You didn’t have these before. I think it’s amazing. And the whole industry is going to go through this transformation.

The change curve, and the rate of change

I want to close with something about change itself.

There’s a model called the Satir change curve. Every one of us sits at a different point on it right now. But just like every transformation before it, your progress is gated by your own engagement – by your own willingness to rethink the craft you have and to let go of things that may have been important for the last two decades but aren’t important anymore.

I invite you to come down this path.

Personally, it’s not easy. And what’s not easy is the rate. Think about it: we had two or three or four years to figure out mobile. We had half a decade for cloud. The web took an eternity – it was the first one. Here, we’re trying to do this in about a year.

Why? Because it’s enabled by all the other capability we’ve built, and because the potential is so big. The return on investment, once we identify things, is measured in weeks or months – not years. That’s a completely different thing than any of these previous transformations.

I hope you heard something here that grounds you.

Software is liquid. The fundamental economic paradigms have changed. You are able to lead through this.