---
type: raw-transcript
title: "The Way We Use AI Will Completely Change in 2026 (Hot Takes)"
youtube_id: nz8VjAtY_Mc
url: https://www.youtube.com/watch?v=nz8VjAtY_Mc
slug: the-way-we-use-ai-will-completely-change-in-2026-hot-takes
published: 2025-11-26
duration: "0:16:05"
fetched_at: 2026-07-21
immutable: true
---

## Transcript

**[0:00:00]** The IDE is dying and so is tool calling. OpenAI is not going to win. And next year, you're going to be shipping code that you've never reviewed before, even as an experienced engineer. Because let me tell you, the way that we use AI in 2026 for coding and agents is going to

**[0:00:17]** look completely different. And so, in this video, I want to quickly cover my predictions with you and why they matter right now. And some of these are definitely going to be hot takes. So, let me know in the comments if you disagree with anything. I am genuinely curious. And before we dive in, yes, I

**[0:00:32]** have partially lost my voice. I'm sure you can tell, but I'm still really excited to get into all this with you. All right, so for the first prediction, idees are dead, at least as we know it, because traditional IDEs where the code is the focus of the interface is simply

**[0:00:47]** going to become irrelevant. We're so hyperfocused on orchestrating different AI agents. So, we're moving towards more of an agent manager interface where we can kick off agents in parallel to work on different features in a codebase or even work on different projects at the exact same time. And we're already

**[0:01:03]** starting to see this with Google's anti-gravity, for example. They have a traditional IDE component, but they also have this agent manager where we can kick off these different work requests for our agents across different code bases. We can review things just like we would with a GitHub PR and we can have

**[0:01:20]** our comments here that it'll address in real time. It's really really cool. And cursor with their new 2.0 update, they also have something like this. And then we have options in the cloud like codeex web and cloud code for the web where we can do this kind of orchestration as

**[0:01:33]** well. It's so high leverage. We can kick off all these different agents to work for us at the same time. On top of that, I'm also working on my own custom remote agentic coding system. So, I can inject my own process for planning, implementing, and validating like you're

**[0:01:49]** looking at right here. And I can do this in pretty much any application, GitHub, Telegram. I'm working on a Slack integration. It's so cool. And the best part is I am giving away this complete system to you, but only in a live stream that I'm doing this Saturday, November

**[0:02:03]** 29th, at 9:00 a.m. Central time. So, come be a part of it. It's going to be a blast. I'm going to give away this entire system and show you how to use it because this my friend really is the future of agentic coding where we can interact with our agents wherever we

**[0:02:18]** actually do our work. So with that on to the next prediction here the different paths to AI dominance. A lot of people think that in the future a single large language model is going to have a monopoly and be the best at absolutely everything. But what really is going to

**[0:02:33]** happen is different providers are going to specialize and focus on being the best at different things. And we're already seeing this with Google, for example, going down the more generalist play. They just want to be the jack of all trades. Anthropic is focusing on being the best for coding. And we can

**[0:02:48]** even see this with the benchmarks. Gemini 3 is just crushing it across the board. And then Opus 4.5 comes out. And of course, the first benchmark they show is the one for software engineering because that is what Anthropic is focusing on. and other providers are going to come up with models that are

**[0:03:02]** more focused on something like creative tasks. We're going to have that specialization more and more where it depends what we're building that will determine the LLM that we use specifically. But you know who I don't think is going to come out on top with any kind of specialization is OpenAI.

**[0:03:18]** And this is probably the biggest hot take in this entire video, but they just disappointed time and time again with GPT 5.1 and 5 and GPT 4.5. with 4.5, they seem to like try to be that creative specialist, but it just really didn't work. And there's so many more

**[0:03:34]** LLMs, especially open source ones that are focused on that. And so, I don't know, maybe they're going to come on top literally next month and GBT6 is going to be released, and it's going to be absolutely killer. But so far, they've been hyping up so many different things,

**[0:03:47]** and it's never ended up being a huge breakthrough. And speaking of more LLMs being available, next up we have the local AI breakthrough. I really do believe that 2026 is going to be the year of local AI. We didn't see that much this year besides Deep Seek at the

**[0:04:03]** start of 2025. I mean, that was a big deal, but then there wasn't really anything more as far as local AI. We had a couple of new models like Quen 3, but nothing super super big. But we are starting to see some new hardware come out that is making it obvious that we

**[0:04:17]** are going to start to be able to run very large models even on smaller devices. I'll have a link to this article in the description. There is a new AI chip that apparently is going to be able to run upwards of 120 billion parameter large language models on the

**[0:04:33]** edge which would be a complete gamecher because right now the hardware requirements is one of the biggest problems when it comes to scaling local AI. And so if we can solve the problem of hardware then we have 100% data privacy and zero millisecond latency for our agents. And that is the dream. And

**[0:04:50]** going back to the theme of AI coding, we are finally going to get to the point where we are not the coders. We delegate that entirely to our coding agents and we are the system architects. And I'm already doing that myself. That's what I'm teaching on my channel in the

**[0:05:04]** Agentic coding course. But it's finally going to become mainstream where we instead focus on the highlevel design, architecture, and validation of our AI coding system. And it's interesting because this actually mirrors the evolution of other engineering disciplines. For example, civil engineers, they don't fabricate the steel beams. They design the structure

**[0:05:24]** and verify the integrity. And that's exactly where we're going as software engineers as well. And I like to think of this as a three-step process. We define our objectives and the system that our agents will operate under. And then we orchestrate by delegating the coding to our agents. And then we

**[0:05:40]** validate the outputs and ensure the quality of the overall system afterwards. And so we're still in the loop. We are the final say in whatever is created, but we're delegating the grunt work, all the coding to our coding agents. The sponsor of today's video is none other than Postman themselves, the

**[0:05:58]** API platform. Basically, every dev under the sun has used Postman to test, manage, and deploy APIs. But did you know that they are now helping you build APIs for your AI agents, which is something that people do not focus on enough? 57% of organizations say that AI has increased the number of APIs that

**[0:06:18]** they manage. And the reason for that is when you deploy an agent to production, it's sitting behind an API and then also using APIs for the tools. And so APIs are no longer just the infrastructure. They're a strategic backbone for your agents. And so making sure that your

**[0:06:34]** APIs are robust is equally if not more important than the rest of building your agent like selecting the model for example. And so Postman makes it possible for us. And what they have here is the 90-day AI readiness playbook, your guide to building this API infrastructure for your agents. So I

**[0:06:54]** will link to this guide in the description. It's definitely worth the time investment. If you don't put time into developing API readiness, I can promise you that your agents are going to fall into chaos when they're deployed in production. And Postman gives us a lot more than just their guide. They

**[0:07:09]** have an AI agent builder when here we can build productionready AI agents sitting behind the Postman API infrastructure. They have a ton of templates for you to get started. You can obviously make your own as well. You have this low/nood builder that makes it really easy to stitch things together to

**[0:07:26]** build any agent that you want. They have their agent mode to help us build and test things as well. And then when we deploy our agent, this is the best part that really leverages Postman. We have all of the monitoring and performance metrics, the dashboard to set up alerts,

**[0:07:39]** all of the production ready infrastructure that we'd expect from Postman. So, I will have a link in the description to the Postman AI agent builder because if you are serious about building productionready AI agents and APIs, you should definitely check this out. And our agents themselves are also

**[0:07:55]** going to change a lot next year because code execution is starting to replace tool calling because the problem we have with tool calling right now is that all the capabilities that we give our agent, they have to take context upfront. And so when you try to give a lot of

**[0:08:10]** different tools to an agent, you completely overwhelm it. And so code execution is a massive token reduction. It's also faster and more flexible because essentially what you're doing is you are giving the agent the ability to generate its own capabilities at runtime by writing the code to interact with the

**[0:08:28]** API or whatever it needs to do. And this article from Anthropic I will link in the description. They talk all about the problem with tools in MCP and how code execution is the solution. I definitely think that this is where we're heading with agents so we can make them a lot

**[0:08:44]** more nimble and lean. And the best part about the flexibility of code execution is it unlocks the next level of progressive disclosure. I know that sounds like a fancy term, but all I mean by that is we have a lot of capabilities for an agent, but we don't actually give

**[0:09:00]** all of them to the agent upfront. Instead, we allow the agent to discover the capabilities and then leverage them in a more flexible way. And so what that looks like is for each capability, we just have a bit of metadata or a description that we load up front. And

**[0:09:15]** then when the agent zooms in on that description, it says,"I want to leverage that capability." Then we will load in the full instructions. That might include scripts or a guide on how to generate the code for that tool, whatever that might be. And so now we can practically scale to infinity

**[0:09:31]** because all of these capabilities don't have to be loaded at runtime. It's just this tiny description. And if you want a really good example of this, take a look at Claude skills. It's kind of the first standard for composable skills or progressive disclosure. And I know I know I've been focusing a lot on

**[0:09:48]** Enthropic and Claude in this video, but they really are on the forefront with their research. And so this is a brief diagram that explains how skills work. And this is focused on an AI coding assistant, but skills apply to literally any kind of AI agent. So you start with

**[0:10:03]** your main context. This is what you always have loaded for your model like traditional tools or your global rules whatever that might be. But then you have this skill discovery. So based on just that tiny description that you give at first if the agent decides to leverage a skill and then you load the

**[0:10:19]** instructions on demand. So you start with what is called a skill.md. This is the primary instruction set for the skill that tells it how to write the code or other references or scripts to leverage. And then you can also pull in these reference files, but only when you

**[0:10:34]** need them. And so there's actually multiple layers here. You pull in the skill.md. And then you might also decide to pull in the forms.m MD. So you have this progressive loading of all of this context that you need for your capabilities. That's why it's called progressive disclosure. So I talked

**[0:10:50]** about how local AI is something that really wasn't that big this year, even though I thought it was going to be. And agent to Asian protocols is another really good example of that. So this is the kind of thing where we have AI agents that operate in a peer network.

**[0:11:04]** They can discover each other's capabilities in real time and interact very autonomously. And there's a lot of potential here. And I thought that is going to be a really big thing, especially when Google released their A2A protocol earlier this year. I made a video on it. There was a ton of buzz

**[0:11:20]** when it first came out and a lot of people thought it was going to be the next big standard, like the next MCP. But then nothing happened with it and it kind of just completely fell to the wayside. And I think one of the big reasons for that is that we have sort of

**[0:11:34]** a chicken and egg problem with A2A or any agent agent protocol. In order for it to be useful, we have to have a lot of people adopt it at the same time. Otherwise, if we build an agent that is A2A compatible, then it has no other agents to talk to. So the whole value

**[0:11:50]** proposition is lost unless we already have this big network that we can attach to right away. But I think that next year that is finally going to happen, especially because of my next big prediction here is that machines paying machines is going to become a very big thing. And Coinbase recently released a

**[0:12:08]** protocol for this called X42. It's a way for us to build AI agents that we expose over the internet, but we require payment whenever someone else interacts with them. And this goes really well with agent to agent because we can create this kind of peer network where we monetize our agents. They are all

**[0:12:24]** leveraging each other but making payments whenever they are taking advantage of the capabilities of another agent. And so we can make money with our agents assuming it exposes capabilities that other people want to leverage through their AI agents. And this is naturally a coinbased protocol because cryptocurrency is just the perfect

**[0:12:44]** solution as the payment mechanism for these kind of machineto-achine networks. We need a currency where it's really easy to do micro payments quickly and globally. And we want something pretty stable overall. So, a stable coin like USDC is the perfect option for this. And out of all the predictions that I have

**[0:13:02]** here, this is probably the newest concept. But I do think that this is going to be something that is going to be pretty widespread starting next year. All right, for the last two predictions here, I want to go back to AI coding because I really do believe that coding

**[0:13:15]** is the most high lever use case for regenerative AI. And so my next prediction is artifact reviews instead of diff reviews. And so in a very traditional sense, when we want to do a vigorous code review, we're going to look at line by line all of the changes

**[0:13:30]** that were made by the human or AI engineer. But coding agents are starting to get to the point where they have full capabilities to show us the proof in the pudding. So instead of us having to review things line by line, we can look at browser recordings they send us and

**[0:13:46]** this goes with remote agentic coding systems where it could just like send that to us in GitHub or in Slack full working demos of a backend API. And so we can rely on these to know that the coding assistant did the job well instead of having to do a full code

**[0:13:59]** review. And if you want an example of browser recordings, we can go back to Google's anti-gravity that I showed earlier because they have Google Chrome directly integrated in the IDE now. So, as a part of its coding process, it can autonomously spin up your website, visit it, scroll through it, take screenshots,

**[0:14:17]** and everything. You can even view the playback afterwards like I'm doing right here. So, it can visually verify your front end and make sure that your application is working properly. So, this is a good example of what I mean by artifact review. And it's so much nicer. We can take a look at this to make sure

**[0:14:32]** everything is working well instead of having to get into all the diffs. And so for the very last prediction that I have for you, we really are tying a lot of things together because we've talked about reviewing artifacts instead of diffs and creating systems instead of coding, the new capabilities we're going

**[0:14:48]** to have for agents with things like code execution. And so we're going to get to the point very quickly where we're going to be shipping code that we have never read before. And yes, I understand that people who vibe code are already doing this, but I'm saying even experienced

**[0:15:02]** engineers are going to get to the point where they trust their system so much that they have the ability to review the code, but they're not going to. We're just going to be shipping things to production after we review those artifacts that we have. And so I'm not

**[0:15:16]** saying that we're going to take the human completely out of the loop, but I'm saying that we're going to have a lot of trust in our system and a validation process set up that includes us. That doesn't necessarily have to be us actually looking at the code. And I

**[0:15:29]** definitely look forward to that. And that's really what I'm building towards every single day with the things that I'm showing you on my channel and what I'm doing in the Dynamis community. And so there you go. That's everything I have as far as predictions with AI going into 2026. And please let me know in the

**[0:15:44]** comments what you think. I'm active in the comments every single day, so I will respond to you. And I want to know if you agree with everything or if you think something that I covered in here is just a pile of garbage. And so with that, if you appreciate this video and

**[0:15:56]** you're looking forward to more things on AI agents and AI coding, I would really appreciate a like and a subscribe. and I will see you in the next video.
