The future belongs to people who can just do things

Folks, thanks for joining. It's a Friday. This talk is gonna be a little bit intense, but there's an arc to it. There's a reason to it. The way I kinda look at it is software engineering is going for the same change that would happen in the architecture space. Right? We like, before we had AutoCAD, before we had CAD, we have we used to have rooms of architects doing.

And after the end of that, we still had architects, but it was just the professional was different. Their identities were changed. And we're going through a similar things, one of those right now. And I'd just like to thank the speakers who spoke today. Like, giving talks is hard. No matter how much you do it, it's always hard, but it gets easier. And if you're thinking of delivering a talk, please do.

It's one of the best things you can do. So let's kick this off. The future belongs to people who do things was a blog post I authored approximately six months ago. And as certain that I might seem in all these things, I don't know where this is going.

I do know things are changing, and I do know things are changing. What I'd like to say is we're in a oh, fuck moment of time. This was my first blog post that I posted back in December, and as I take you through the talk, you might actually have if you haven't had one of these already, you might actually have one as well.

And it started when an engineering director went to all the staff and principal engineers at Canva and says, hey, can you go deep with AI over the Christmas break? I'm like, okay, I tried it before. Wasn't that interesting. Wasn't that interesting. So I said, hey, downloaded Windsurf, and I said, yeah, can you convert this Rust audio library to Haskell using GHC twenty twenty four?

And use Hoogle to search for the right types and functions and include a comprehensive test suite using Hspec and QuickCheck. Now, it's really important when you make your changes, run a run a build after every code change. And yeah, you need to write tests, and do that automatically for me. Do that automatically for me, because I heard it was possible to run a loop to actually automate some of these things.

So I took my kids down to the local pool, left that loop running. When I came back, I had a fully functioning audio library in Haskell. Now that is stupid. That is so stupid. You're probably wondering why am I doing an audio library in Haskell? It's like the worst thing to be doing audio in. It's because I knew it was not trivial.

Right? I'm continually searching for proof that this is real and what it can and cannot do. If it was regurgitating the same Rust library back to me and regenerate it, I'm not that interested because it's not new. But here, we've got an audio library in Haskell for core for core audio and macOS, and it automatically generated the bindings to cross over the FFI, like, functional programming over to C, and it worked, and my jaw was on the ground.

So I offered this blog post, like, oh, fuck. And in that, it was I included it and said, from a period from now, software engineers who have not adopted or started exploring software assistance are frankly not gonna make it. Engineering organizations are now split between those who have had that moment and those who have not.

And in life, I've been somewhat fortunate to have dealt and seen exponential change. And a background in software development tooling, I started more writing. Started more writing. I could see things. I could see that we need better tools.

Like what we had today, even now, doesn't make sense for the primitives that now exist. And then I did a follow-up blog post, and my coworkers back in January thought I was mad, utterly, utterly mad. And I was saying, hey, wait a sec, wait a sec. Why are we designing things for humans?

Like, what is an IDE? Think about it. IDE is basically a typewriter. It's a single plane of glass that we just type into. Like, seems really weird that, like, the entire industry is putting all these AI tools in the IDE. It seems like it's kinda like it just doesn't seem right. It's like it's a high power tool in a low power interface, and this interface has been the same roughly since Turbo Pascal in 1983. Like, has AI invalidated the existence of IDEs?

So we're starting to think about along these lines. Like, what has changed? What is changing? What if we designed around AI tools first, humans second? And then I go a little bit deeper. I'm like, hey, why does an engineer only pick one story? Now in my youth, I used to play a World of Warcraft, and anyone who played World of Warcraft knows about multiboxing.

Multiboxing is where you have one computer and you play multiple characters at once. And I realized, wait a sec. Wait a sec. What happens if I have multiple versions of cursor open concurrently? What could why why are we only picking one story? Like, because they output so slowly. Why don't I like, why why is it the norm?

And it seemed, when I was speaking with coworkers, they were stuck thinking at a primitive level of what if I had an AI coworker? And they haven't yet got to the thought of, no, fam, what if you had a thousand AI coworkers that went ham on your entire backlog all at once? Now, that's Annie Betts. Annie Betts was my mentor when I was first getting into software engineering. A lot of the software you use day to day from Slack, the GitHub desktop app, or the entire Electron ecosystem, you've seen a software updater, that's Annie.

She's now at Anthropic. When certain people will caliber, say certain things, and they start doing particular things, I pay attention. There's two people I pay attention to. It's Annie Betts and Eric Meyer. And all of the biggest brains in computer science that were retired are coming out of retirement now.

There there's moves happening here. So I guess our profession is at a crossroads. It's kinda like an adapt or perish moment is the way I see it. And it didn't take long for founders to start putting out blog posts and tweets saying, I'm no longer hiring junior or mid level software engineers.

It won't be long until AI is writing all the code from Gumroad. Shopify followed up very fast and says, at Shopify, using AI effectively is no longer optional. It is a baseline expectation to be an employee at Shopify. Here is a quote from the AFR.

It turns out some divisions embrace this mandate for using AI a little bit too well. Last week, Canva told the majority of its technical writing team its services are no longer required. So folks, introductions. I'm Jeff. Previously, I was the AI AI dev productivity tech lead who rolled out AI at Canva.

But as of two weeks ago, I'm now joining Sourcegraph and I'm building next gen AI tools. And I figured, look, if I'm gonna be building these tools and it's gonna have these implications for society, I've got to throw some ladders down to explain what is going on. What is going on so you can adapt. So this is AMP.

This is a video that came out this morning and it's got not we're completely unrelated. The product is now three weeks old and it's being very very well received. And I'll I'll give you some showing of it, but basically, it's a very, very small team in a much bigger company that are building really good developer tools.

So on the note of, like, publishing research, it's all on my website. What I'll be doing is stitching it together today. This is a six month recap. As soon as I published the blog post that, hey, some people are not gonna make it, coworkers came to me and go, Jeff, what do you mean some people are not gonna make it?

And this is the blog post. At FruitCo, there are seven software developers, and the company does six month performance cycles. Right? This is a this is the same in every single company. It's easy to point blame to any one particular company, but AI can now be purchased with a credit card. So these dynamics will happen within a span of time.

Some companies, it will happen faster, but some might take years to happen. So unfortunately, Lemon doesn't make it in the performance cycle because they're all Lemon. Then, you know what, another performance cycle whizzes on by. Orange and Strawberry are really shocked because they're normally like a high performer. Like, they're really, really shocked to get a low performance rating. So they start looking for an edge.

Right? They start looking for an edge, and they they download Curse or Windsurf or any one of these things, and they start paying attention to it. Now, this is where it gets interesting. This is the journey that I personally went through and myself doing research within the organization, and I managed to map this out as the people stages of adoption.

That was me. I was pineapple. And I was like, prove it to me that this is real. I tried it. It was crap. Right? Didn't wasn't good enough. Now this is the curse, is you can be a principal engineer and you try it once, and then you can completely ignore that it's getting better continually.

You completely miss the point that it's getting better every month. It's getting better. The tool's getting better. The foundation models are getting better. And when you hear someone when you hear someone say, yay, it's really good, it's easy to dismiss it as hype. It's really easy to dismiss it as hype. I was that. I was dismissing it as hype.

So six months whizzes on by, and at the next performance cycle, pineapple and grape are at the bottom of the tier list. That's really weird. Why are they at the bottom of the tier list? They're previously at the top. It turns out because the other coworkers would be using AI, and it's able to deliver a force multiplier of output compared to what they were doing, naturally, they're being graded downwards when compared against their peers. So Banana is a little bit shocked, starts taking notice, and starts investing in themselves.

But the thing is, the earlier you start playing around with AI, the more it kinda compounds and because you're learning what it can and cannot do. So unfortunately, the results are predictable. Grape really failed to adopt with adopt with the changing within the engineering culture within a company.

It's no longer with the company. And this is the curve. This is what I was able to to map out. Grapes up there is like prove it to me that this is not hype. Prove it to me it's not hype. And then you you get like the I'm experimenting with AI. And the end result here is there's a there's a middle.

There's a bit of a middle there. You get stuck in the middle. You're like, oh, fuck. Do I have a job? Like, soon as you start playing and experimenting with AI and you realize what it can do, it's really scary. It's really, really scary. But there's a cliff that you can cross over, but the question is, how do you do you cross that, to go for that journey from like up where I was over into like, programming AI, not just consuming, but programming.

Programming with AI is gonna be a baseline expectation. Right now, you're consuming AI. There's gonna be a baseline expectation that you can use AI to automate your job. So I concluded that blog post that there's not gonna be a mass layoff for software developers at companies because of AI. What we'll see is a natural attrition between those who invest in themselves now and those who adopt, who do not.

The displacement that will happen is really coming down to whether you invest it in yourself and you're aware of it happening and the changing dynamics. You see, there's a bit of a there's a bit of a rift between 2024 and 2025, the skill set is has that founders want is changing.

They they in 2024, you can be a software engineer and you'd be a really good software engineer. But in 2025, founders are looking for software engineers that are AI native, that use AI to automate job functions within the company. It's kinda like imagine me a DevOps engineer in 2025 and not having any AWS or GCP cloud knowledge.

Like, it's one of those moments that rift is happening. So it's really important if you're an engineering leader to actually steer people past that emotional phase in the middle because you get stuck like deer in the headlights. So, so important. It's to build the support mechanisms, and you'll you'll see it in companies that are like, go play with AI.

Go play with AI. Just know eventually go play with AI is expectation of do more of AI. And for the people who actually get AI, it's also if you're an engineering leader, it's also the tech industry is popping right now.

Absolutely popping right right right now. So there's gonna be some retention issues. Like, so you want people to use AI, you and wanna have the right people in your company that are using AI, but at the same time, the tech industry is popping. If you figure out how to automate and do some of the things I'm talking about, like, it's probably some of the best personal development you do this year.

So for those that don't, don't invest in yourself. This is gonna be kinda dark. I remember when I posted and wrote some of this wrote some of the blog posts and doing some of the research that I was publishing, I remember getting off the train and just walking to the office and it was kinda like the movie The Sixth Sense.

And I was like, I see dead people, but they're not dead, like as in literally dead. It's like, oh, these people don't know they don't have jobs yet. Like, could see the displacement that's happening. So I wrote more. I started writing more and as I started doing more and more research, what I found was I originally thought if you you just you know, just go from the left to go to the right, and you're sweet, mate.

Nope. It turns out when you fight it's it's it it is an emotional struggle and roller coaster because the more that you see that AI can do, the more it throws you back into the center asking, will I have a job in the future? But you're like, oh god, I can do that. It throws you back. So if you're an engineering leader, it's really important to actually support your people through this motion.

It's not just a simple just adopt. No, it's gonna be a little bit circular. It's a big people change aspects for organization. Now, one of the things I was been looking at is the concept of Overton window.

In political theory, there's a way of mapping society through this, which is the policy for society. But they're also beautiful for essentially articulating disruptive innovation, the things that AI is happening right now. And the current thing we have right now, you see all the vendors, they're all, like, putting AI in the IDE.

You might notice it. Everything's in the IDE. But, like, five months ago, I'm like, no. The IDE. No. The IDE. It's not like, it's dead. And then last week, Dario from Anthropic is saying, yeah, the IDE is dead. So it's kinda like kinda validated. And the way I work with IDEs now myself, I just use it as a file explorer tool.

Like, I don't even use AI tab complete. I'll show you. And so all the vendors are shipping into the IDE because that is what is susceptible and non scary. That's the best way to look at it. Susceptible and non scary to people. But we're starting to get other approaches now where this is AMP.

It works both in Versus code and also in the command line primitive. It can be wrapped to do other things. And there's also Claude codes. We're starting to see the Overtur window slip a little bit. And this space changes fast. Like, I spent a lot of time pondering what is unthinkable?

What is so radical and unthinkable that it scares people? Because right now, even this here scares. What is the future? So I'm gonna show you how I do software development these days. Cool. Okay. So AMP is both a command line tool and an extension. Hey, can you please enumerate in each one of these folders?

In each one of these folders, run a git f d x clean and a git reset hard, then a git pull, and can you run a diff, like make sure all the folders are the same and use up to 500 sub agents? Yeah, so it turns out it was internet related problems. Cool, the transcript's done, let's kick it off.

So this is the way I do software development these days. It's gonna do inference and figure out what I want, and then it dries particular loops. So here we go. It's it's come up with a whole bunch of sequential to dos. It's enumerating for each one of the folders, and it's running those commands. So while that kicks off and runs, let's keep on going.

Something that I've been really thinking about is essentially what does a future organization chart look like? And this is really hard to say what a future organization chart will look like. It's probably not 2026. It might be 2026 for some companies, but for other companies, it could be ten, fifteen years. What you just saw is a baseline coding agent that that's essentially a general purpose thing that can do anything.

Now AI managers might seem a little bit weird, but, like, if you've ever been using cursor or any of these other tools, you see it do dumb stuff. Have you noticed that you're in there correcting it, and you're course correcting, etcetera? Well, you're software developers. What if you can automate? You could create a supervisor that automates that correction.

So the more times you automate when it goes off the track, the less you have to attend to it, it goes off, and that's AI managers. So AI managers are now real. They are now a real thing. And there's people on social media who are automating automating things with ClaudeCode and AMP and other things like that.

Now, probably one of the most important pieces of personal development you'll do this year is to build yourself an agent. It is literally 500 lines of code and a couple of key key concepts. Just go build yourself an agent. It is you can actually take this blog post, put dump it into cursor, amp, GitHub Copilot, and it'll build you the agent.

It will just grab the URL, etcetera. And understand that when all these vendors are going to market and they say, my new AI tool, the reason that everyone's doing it is because it's so simple. It's so, so simple. Learn what it is because we're in this this kind of this age of a little bit of, let's say, the bit of mysticism in that sense, and people are selling magic beans and, like, understand how it works under the hood.

That way, you know when someone says they've got a code review tool powered by AI, you just go, oh, it's just this loop with these three primitives with a different system prompt on top. Go build the agent because founders are gonna be wanting people who know how to build agents going forward. Now, that might seem a little bit cooked, but if I was to ask you what a linked list is, you should know, it's been a classic interview question.

It's been a classic classic interview question of a data structure is what a linked list is and how do you reverse it and etcetera. Going into 2025, we now we're starting to see the questions going is, what is an agent? Build me an agent. Show me. It's like into the details. The same way you would have a interview question for reversal link list. For reference, Canva three days ago has publicly shared that they've restructured the interviewing process, and we're gonna see start to see things like that. They want AI native people who can automate software development going forward. So there's a clear line.

This is gonna be something that's gonna be going forward, it's important to understand. And that's what I I'm starting to think that just because someone is an experienced software engineer doesn't mean they're necessarily an experienced software engineer going forward when you think about the dynamics of of employees share employees sell time sell time and skill for money, and then buyers' appetites change.

Buyers' appetites change, and it's changing fast in some companies really fast. And one thing I've been thinking about is LLMs are really kinda like mirrors of operator skill, and a lot of people try an LLM. They try AI, and it doesn't work for them.

But perhaps they're mirrors of operator skill. And one of the most pressing things going forward for companies as they're trying to find engineers who are AI AI native is how do you even identify if someone's really good with AI? How do you even identify if someone's really good with AI? The answer is you gotta watch them.

You have to watch them. Interviewing in companies has classically all been about classically been about a multistage filtering process. Multistage filtering process. But that multistage filtering process has been blown up. Here is a video of one of the many tools that's now available for candidates to use to actually cheat any of the hacker rank and leak code coding challenges.

Here, this engineer used it as university student, and yeah, he got acceptance offers in all the big tech companies using it. So the question of like how do we actually interview going forward, it's it's a huge, huge, huge problem. So I've been thinking about it, and I'm like, okay.

What would a phone screen look like going forward? Because with these gates blown up, how do you identify someone who knows what what it is? It turns out each one of these LLMs have been trained on different subsets of data, And some excel in some scenarios, and some are terrible in other scenarios. If you needed to do security research, which large language model would you use? It's Grok.

Grok has no safeties. If you're on red team and you wanna be doing offensive, like, offensive work, you can't do it with anthropic because the safeties of anthropic inhibit you from being able to protect your company. So that's an example, like a phone screen interview. Or if you needed to summarize a document, which LLM would you use? The answer is Gemini.

Gemini has this massive context window, and Gemini has, in peak Google engineering, there've been reinforcement learning to make it the magical one shot wizard that will summarize a document and get engineering perfection. That's so most people think about this along the lines of all these LLMs are the same.

Well, that's like cars aren't the same. You've got a 40 series. You've got a hatchback, and you've a soccer mom car. Like, they're all different. They all have different uses. And as you start playing with this, you start to notice, like, latent properties where they're good at. Gemini is not very good at automating software development. If you want to automate software development, you need a task runner that can do tool calls, and it turns out the one for that is actually Anthropic.

Anthropic is exceptional at incremental tool calls, and that it allows you to automate software development. And again, the best way to determine if someone is a skilled operator is just to watch them dance with the OLM. But that's expensive. You can't have all your product engineers, like, watching someone as they're working with the LLM.

The way to look at it is it's very similar if you're watching someone with a screen share if they're doing a debug challenge, and are they productive in debugging? Like, you you can pick, like, an experienced operator and skill if they write their tests, they do print statements, or, like, how do they step debug and work around it, that's a sign of someone who's, like, really invested in their skills.

And that's always been a great way to identify someone. The same play is now, but the idea of how do you do the pre filter gates, I've been thinking for three months, I don't have an answer. The gates have been blown open. Some companies are going back to in person interviews now. So one of the things I've been thinking about here is one of the things I've been thinking about here.

So the WiFi dropped out. Maybe this will be a one or two. Yep. So something I've been thinking about for a really long time is when someone says AI doesn't work for them, what do they even mean? What does that even mean when they say AI doesn't work for them? Like, are they which identity are they coming from?

Are they talking about AI is not working in the workforce, or are they talking about where they've tried it at home in a greenfield project? Right? Have they have they have they that distinction really matters because, I guess, employees trade skill and time for money. This is one of the biggest transformations that we're having in this space. And if they're missing out on it, on that skill up learning, then what does it mean for topics of employability?

So I'm really, really worried about these topics and what's going forward. If a company is struggling for AI adoption, that's understandable. That's my job job to figure out to make how to make these tools work well with large mono repos. But it's the employees I worry about. You see, I guess there was a time when employees moved on from companies because they wouldn't adopt cloud, AWS, etcetera, because they they saw the the the crisis for them for being employable into the future. So this is also a problem for companies itself as well for retention, etcetera, as more employees want to keep their skills up to date. If AI is not working in that company, then what does it mean for the company?

So I hope that employees are putting time in to remain relevant for future employees if they try AI at home. Because if you try AI at home without all the restrictions in the corporate code bases and large mono repos, there's a beauty in AI. It is absolutely beautiful.

Absolutely, absolutely beautiful. The way I like to describe it, it's like a musical instrument. Like, everyone knows what a guitar is, but with a guitar, you know you need to put deliberate intentional practice into it to get good at it. But for some reason, software engineers are picking up guitars, but I'm not talking about guitars here. I'm talking about AI.

And that they it doesn't work, and they just put it down and say, it doesn't work. That's really strange. Like, you wouldn't do that. It takes time, skill, and experimentation. Skill can be developed through deliberate intentional practice. In the in the circles around me, the people who are getting the most out of AI have been putting in this intentional practice.

And, yeah, they don't pick up the guitar, and they go they keep practicing. Now what does does practice mean? Like, I'm talking in the in these analogies of musical instruments, and what they do is play. They pick up something. They pick up something, and they go, can it do it?

Can it do it? So last week, I was hanging out with a friend on Zoom drinking margaritas, and we're both reminiscing, which led to a conversation about COBL. Next thing you know, we're like, can AI do COBL? Like, can it? I don't know. I don't know. Couple of moments later, we opened up a coding assistant and built a calculator in COBL.

And we're just sitting there going, what the hell? Wow. Okay. Because in the spirit of play, can it do a reverse polish notation calculator? And it turns out it can. It can do an RPM calculator in COBOL. And we said, what what what can it cannot do? Like, what what what's the stupidest thing we could possibly do with AI just for the spirit of play and fun?

And we're like, let's write some unit tests. Is there a unit test framework for COBOL? Yeah. There is. And it did it. And the next time we were like, oh gosh. Okay. Let's take this up on a level. We've had a few margaritas at this stage. And we're like, okay. Create a reverse polished notation calculator in COBOL, but use emojis as arithmetic operators. Does COBOL even support emojis?

We don't know. We're about to find out, And yeah, it is possible. COBOL supports emojis, and that's the world's first emoji calculator in COBOL. The thing I'd like to say, it is it is all about essentially just the deliberate intentional play and that experimentation of what it can and cannot do and learning new techniques and skills.

It is very weird. As engineers, we're used to, like, very deterministic outcomes, and these are nondeterministic primitives. It's gonna take a little bit of adjustment to get used to, but LLMs can be programmed. Now you might be thinking, hey, that's that's not interesting, Jeff.

That's not interesting. That's a toy. It's just like a Vercel application. Do you wanna see it go scale up? Here we go. Here is four headless agents that are automating software development. I'll get into it if I have time.

On the left there, that is myself cloning tilescale.com, the company, headless while I'm just sleeping. That there, the middle one there is HashiCorp Nomad. That's just Garrett open sourcing and that was a company called InfaScale. It turns out as you start learning different techniques, you can drive fully autonomous headless loops.

That's why I like to think of it as kinda like a musical instrument. I still don't know what is real and what is bullshit with everything that's going on, and I've continually published research and proven to myself what is real. I'm deliberately hitting the gym and doing things. And one of the projects I've been working on now is if I head across over here, is I'm like, okay.

Let's make a compiler. Can an AI make a compiler? Compilers are fantastic. They're fascinating. I never thought I'd be making a compiler. And this has been running on full autonomous headless loop, and we're now into the standard library concerns. Last night, it implemented the Postgres adapter and MySQL adapters, which will allow the programming language to do it.

And it's really weird because the it's actually programming a brand new programming language that it has no training data on. That's really strange. How is that even possible? I don't know. So over here, for citations yeah. Here we go. I didn't write any of this code.

It's implemented a generic algorithm. It's using a lookup table. It turns out if you give it a lookup table into the context window and you say this lexical structure is this in Golang, but this in Kursed, it's able to it's able to use it enough to tickle the leaded space to actually achieve those outcomes. It's crazy. It's absolutely crazy.

Now, this is the point where cool. That's working from the from before. Let me show another way of working with AI. Last night at speaker's dinner, speaker dinner and friends, we had a we're doing some fun stuff.

In the spirit of play, people ask me, what is play? So I'm like, okay, let's do it. Let's rebuild it. Because I I I built this before, so I know it's a possible thing that AI can do. Hey. Can you build me a Google Chrome extension?

This Google Chrome extension is called piss off all the designers in the world. And what it does is this Chrome extension, it allows someone to toggle a behavior on and off. That behavior is when it's enabled, it changes all the fonts on the web page to Comic Sans. Can you go build it, please? And it will go through and just build it.

And we're sitting there talking about fonts and typography and we're just and the topic of Comic Sans came up, and I was just, yeah, that's kind of fun. Just to show people that it is possible and what attentional play is that are approaching this from a from a beginner's mindset and play. Because we've essentially got a, like, a reset in time here.

So this is gonna build a Google browser extension that force overrides every website to be Comic Sans. For the basis of time, let's see how fast it takes. I might move on to the slides and come back to it, but it works. It works. For some reason, AI is very, very good at building browser extensions. Exceptionally good at building browser extensions.

I don't know. I really don't know. So Remember this organizational chart I was talking about? The idea of AI managers and automating things.

In that livestream and in the compiler, I've actually built my own supervisor and AI manager. And the idea is when I've noticed things go wrong with it, it automatically programmatically course corrects. So that's how I'm able to get this level of, like, headless automation of software development. The way you do it. The way you do it.

It's really simple. You have a long conversation with the LLM. Most people use the LLM and they ask you to do something. You should not do that. To build the compiler, what I what I did was I had a prompt. It's like, hey. I wanna build a brand new programming language. It's just like Golang, but I want you to replace all the lexical keywords to be along the lines of Gen Z slang.

Do not implement. Right? So and then I had continual discussions with it. Like, what approach do you wanna take for the Lexa and Paza? Like like, what are you what are you gonna do? Like and just kept loading up the context window of activities that I want to do. And then I said, okay. I want you to generate the specs.

And they are basically PRDs. And then you just dump out the product requirements of all the application, and then it would fan it out. From there, the next pattern to make this work is essentially a technical engineering practice, as I like to call it standard library. When we build AMP, we use Svelte five.

For some reason, Anthropic keeps bringing back Svelte four. So we've got the standard library prompts that essentially programming the LLM to say, stop giving us the old version. Give us five. As soon as we did that, it stopped giving us the old version. LLM outcomes could be programmed, and can be programmed and controlled. Really important. So you take these two concepts for generation.

One could bring your product requirements or what you wanna build. You take the other one over there for your standard library for technical patterns and practices, wanna use OTEL and what else have you, and it just works. So a lot of people, when they use cursor, they they they just accept the defaults and then they think it they think it's bad. They don't have the realization that you can program the outcomes.

You can control these outcomes. You can build lots of different prompting rules, save them, share with your coworkers, and all of a sudden, it's it becomes increasingly less wrong and customized for your company and code base. Now, another concept is really, really important. It's a topic of back pressure. Back pressure is really important.

So you've got the specs, you've got the standard library, which is the generation stage. Back pressure is really simple. It's your build result. It's the Unix return code or Windows like return code for a process. And you do the build. Did it work? Not work? And then if that didn't work, it puts back pressure on it. Same for tests. Companies that have large test coverage are gonna be find AI adoption much easier because they can put back pressure on the generational loop. If you wanna do code migrations between one version of.net to the next, you need to have test coverage that way you can put back pressure on the loop for the agent.

Now this one scares me. This one scares me. In the livestream in the livestream there, and I explained that, like, that's essentially took that approach. And what I did was you can actually drive LLMs like a Bitcoin mixer over intellectual property. You can feed it source code.

You can feed it product documentation if you don't have that source code, and then you can generate a spec from it. And now you got your spec, you have the ability to essentially at least clone a company. And that's gonna be really, really fascinating implications, what that means for society and founders. Like, what happens when the founder of Tailscal, like, they've just raised, think it's a $130,000,000 US.

What happens when their principal engineers leave that company and three or four of those best mates who actually know how to what to do, they run those type of loops. What does it mean for the unit dynamics for business when you can actually do that type of thing? That scares me. That really, really scares me. Now if you wanna get good outcomes for the LLM, one of thing you gotta do is remember this cut this is so important.

So so important. People do endless chat ops with the LLM. What they'll they'll go, okay. I wanna make this color of this button red. And then they'll go, oh, can you make me a butt a back end controller? Right? All within the same chat session. Don't do it. Keep creating more context windows.

Keep doing new chat sessions. Do it like every time you got a new activity. If it feels like the LLM's going off off track, I like to think if the bowling ball's the in gutter, don't try and rescue it. Just create a new context window. Because what happens is context windows are basically memory that can be mallet. You can assign memory or you can assign things into the context window, but it cannot be freed unless you create a brand new context window. So it's kinda like we're programming with C if we're talking into analogies.

You're allocating memory, but you can't deallocate it. But that changed. This was four days ago. About a month ago, I did blog posts talking about the notion. Wouldn't be really cool if we weren't programming in c, but instead, what we had was async futures and the way to essentially have automatic garbage collection. So a main, you have a process, and you have a thread, and that thread can create a a future.

And in that future, it could do, a build result, which is like big Vobos. If you only got a 154,000 tokens in the context window for allocation of memory, instead of allocating it to the main process thread, right, and then blowing up the stack, what if you can just create a future? And in that future, it can kick off other sub agents.

Basically, it's async a weight with garbage collection. It's now real. And what we've got here is it's each one of those things, you can spawn off one or more or many of these things, and it's a very powerful primitive. So some closing ponderoos. Removing waste from your company and system and process is gonna be a big accelerator than adopting AI.

A lot of the things need to be very, very real. It's a lot of things. It's process and systems that hold back a company. Or it could even be creating the right permission culture if you're an engineering leader to enable people to get stuff done. Ideas are everything now. Like, remember the old saying that, like, ideas are nothing, execution is everything? What does it mean when an idea can be spoken to a computer, and then it's a now prompt and it just goes and does it? Ideas are now important because ideas are now execution.

One thing's for sure, stories no longer start at 0%. They may and the agentic loops I'm running, there's holes in them. But I know what those holes are because I've been studying, and I see that repeatable where the holes are. So then I just program another agentic loop to patch those holes, right, that targets those particular use cases.

But one thing I definitely know for sure now, stories no longer start at 0%. They they they start at 50%, 60%, 70%. And then the last part, it's software assistance. It's not software software development replacement. And it comes into how do we even allocate work now? Why do we even have Jira?

In the team that was reporting to me at Canva, we brought in the spec based workflow to build some AI coding tools. And the end result was we needed to have in you know, the boundaries. Like, you do the back end. I'll do, like, the AI stuff, and you do do that over there. Because the way we allocate work normally is in really thin slices because work is normally somewhat slow, but it's allocated in a way so you don't step over yourself.

When you run these full loops, the end result is that you actually need to have operating boundaries because it's just so powerful. Stuff just gets done fast to the point where you're outputting work of multiple coworkers of, like, weeks of work. It's why do we even have Jira now?

I don't know. Trust in software has changed. Trust is inverted. So with the compiler, I chose because it's easy to verify if it works or not. It either compiles something or if it doesn't, and then you benchmark it against other programming languages. Easy. But like if you're running these full loops, you don't just ship it to production.

That's like this is the vibe coding. I hate this vibe coding notion. I want vibe engineering, like, where there's full accountability for what you build. It shouldn't be AI generated this. You should be able to explain exactly what happened. Because the way software has been built in the past is within with Lego blocks of trust that stack and compose upwards.

But that's changed now. Instead, now it's inverted. And verification of how it all works, You can do things, but it doesn't mean you should ship those things. Software engineers definitely have a job, but that job is now different. But software engineers are getting stuck because their identity function of what it means to be a sub software engineer is being erased by AI. AI is a an erasure device of people's identity.

Are you a back end developer, front end developer? Do you use Emacs? Do use VM, Ruby, Node? Doesn't matter. You're now just all software engineers. And if someone spent a long time, like twelve, fifteen years specializing being a back end Ruby developer, all of a sudden, anyone can be a Ruby developer. That's a emotional struggle to get through.

And now as one thing I've also been thinking about is what's the point of libraries? Libraries were designed for human, for reusable software, and, like, what is the point of open source now? The people around me who have been applying these techniques and if you use them, you might see that, like, dealing with open source is a real pain.

You gotta get the bug fixed. You raise that pull request. You gotta nag the maintainer, etcetera. Now we just co generate everything. It's really, really, really, really weird that something's changing here. Again, the the emperor has no clothes. All these AI vendors including us, we're all selling the same 500 lines of code in a while true loop, and you're throwing tokens onto it. Go build yourself an agent.

It's really important. And as I close this out, it's a really bad year to be asleep at the wheel if you're at a high performance, cutting edge company. These changes are not gonna affect everyone all at once, but at some companies, it's happening really fast. I'd really like you to just go forward and just do things, and just use these techniques, prove to yourself, go lift plates, send me an email. If it works, doesn't work, I wanna know because I still don't believe this is real, but it's at the same time, I'm pushing some things that just should not be possible and that it's working. It's weird.

Thank you.