Transcript — "Top #1 Opportunity for Senior Engineers: Agentic Engineering" — IndyDevDan

What's up engineers? Andy Dev Dan here. This is going to be a raw video and it's more of a message to myself. I just got back from two weeks in Greece completely unplugged and I used the trip to compact my context around one question. What's the greatest opportunity available for senior engineers? I came home with one answer. The opportunity is the same it's been for over a year now. Agentic engineering. The opportunity is the same, but the size of the opportunity continues to grow. So we have to grow with it. Andrew Carpathy just called out aentic engineering directly at the Sequoia AI ascent. When Carpathy named something, the industry follows, which means the window where you're early is closing. By the end of 2026, Agentic Engineering will be the default. On this channel, we've been betting on Agentic Engineering since Clawude Code was released way back in March 2025. In fact, we've been earlier than that. I own the domain name agenticengineer.com

[00:01:00]

where myself and thousands of engineers, some of the best engineers from top companies that you know have accelerated past the industry by pushing the ceiling of agentic engineering, not the floor of vibe coding. It's not enough to be early. You have to keep showing up because the game is always changing. Here's the fact on the ground. Two engineers using the exact same agent with 200k tokens can get massively different results. In this video, I want to talk about the five pillars that make up the gap between low and high performing agentic engineers. These are the key ideas I'm focusing all my time and effort on right now. So, I want to share them with you here. We're going to talk about agent harnesses, software factories, extensible software, always on agents, and agentic access. If you're interested in using these ideas to get the next generation of results today, stick around. This is exactly what I'm thinking about every single day to win by achieving the ceiling of what's

[00:02:00]

possible. So, let's reset our context on the top one opportunity for senior engineers. Agentic engineering, the agent harness. Whoever controls the agent harness controls your results. Why do I say this? Let's break it down. Let me start with a crazy stat. I'm building one new custom agent harness every single day. It's catching up to the total number of skills and agents I create. Why is that? It's because I want more control over the agentic engineering experience and owning your agent harness is exactly how you do that. Let's just be really really raw about this. We're talking about cloud code. We're talking about codeex. We're talking about open code. These tools are fantastic. They were a great start. They're a terrible place to finish. Why is that? It's because the agent is everything. It's the agent that gives you the superpowers. The agent unlocks the agentic speed, right? You know this human speed is too slow. The agent lives in the agent harness and therefore whoever controls the agent harness controls your results. These are just the surface level things that you'll

[00:03:00]

control when you own your agent harness. As many of you know who tune into the channel, I use the piecing agent. The pi coding agent lets me build composable units of customization. Okay, it allows me to build a stack of unique experiences that combine to build a net new agent harness. So simple examples we've talked about on the channel. Multi- aent teams. For those of you that are new to this channel, who are just tuning in right now, we don't just talk about this stuff. We actually build against it. So let me just open this up for you. UIA J team. This is a custom PI agent harness where I've created a multi-team orchestration system. So this is a form of multi- aent orchestration, right? So I'll say ping your teams. Then the orchestrator will ping all of its teams setup brand UI generation validation. And then the team leads also connect and coordinate with their workers. So there's three tiers of agents here. They're operating in a chat room like interface here. And as you can imagine, this is impossible with any out of the box default agent harness that you're renting. What's another example

[00:04:00]

of a customization harness? Let me show you my default out of the box harness where I've stacked up and composed different slices. Here we're pulling out skills, agents, commands from any location. Right now it's just using that default since I'm in a temp directory. But you can also see here my agent communication system. I have agents operating on this network that I can directly prompt and talk to right from this agent. Right? This is just one additional example of how you can customize and control your agent harness. Whoever owns your agent harness controls your results. I'm a huge fan of cloud code. I've been using it since the beginning. But this tool is the floor. It's not the ceiling. It's just the beginning of what's possible with tools like this. And so I'm building a new Asian harness every single day. It's crazy to say that, but it's true. I'm experimenting. I'm getting more control over the agentic engineering experience. Your tools directly shape what you believe is possible. And with the PI agent harness, I see no limits. You can see I've got two agents on this network already. I have a presentation Opus 4.7

[00:05:00]

agent and then I have a helper Gemini 3.5 flash agent testing out the capabilities of that new model that just dropped. And I'm using these two agents together on my agent network through my custom agent harness. This is part of the advantage you get when you own your agent harness. Right? You want to control the experience of your agentic engineering. If you don't own the agent harness, you'll always be limited by what another tool is telling you what you can and cannot do. All right? So you can create a sandbox tool. Every prompt you write, every thing you do, your agent is operating in a sandbox environment just by default. Of course, you can recreate sub aent delegation. You can add damage control like we've done on the channel in a very custom way. You can add model fallbacks. You can route to different models. There's just endless ways to use and build your own custom agent harness. And what does this give you in the end? It allows you to ultimately build with one tool. You can generate many versions. And again, I use the PI agent harness. Shout out to Mario for building such a great tool. And there are really kind of two classes of agent harnesses you can build. You

[00:06:00]

can build engineering pattern focus agents like the pietoie agent harness we talked about last week. I'll link that in the description. You can build agent chains. You can build the verifier harness we talked about a few weeks ago where you have an agent always checking over the work of another agent. But then you can do something really really powerful and more important that many engineers are not tapping into. You can build domain specific agents that do one thing extraordinarily well. DevOps harness, a testing harness, a billing harness. You know, the specialization is truly endless. But if you don't own the Asian harness, you cannot specialize your agentic engineering experience. One tool, many versions. Specialization is the moat. This will always be true. If you can specialize the experience to outperform someone using an out- of-the-box agent for your product, for your service, for your application, you will win. Whoever controls the agent harness controls your results. So, you want to own that. So what's another key pillar of agentic engineering I'm centering myself around to get that next set of results. It's of course the software factory. And the big idea here

[00:07:00]

is you want to be building factories not features. What does this give you? It gives you onspec results every time. So whatever you teach your agents to do is what you're going to be able to tap into over and over and over. Why are the best engineers using software factories and not just building the future themselves? When you are working on your software factory, you are building the system that builds the system instead of going direct to your new app feature to your new landing page to some new API you're building for a client for some service or setting up some accounting spreadsheet garbage. Instead of doing any of that yourself, you are building the teams of agents, the systems of agents plus code that does it on your behalf. And so you're moving the unit of engineering work into the system that builds the system. You're moving your focus into the factory. And the first place you see this is the plan prompt or the spec prompt. You're giving your agent a formula for how you create plans for how engineering work is done. Let's be super clear about this. What is a

[00:08:00]

plan? It's a prompt scaled. That's all a plan is. It's a more detailed prompt. But that's just the beginning. There's planning, there's plan reviewing, there's scouting, there's validating, there's the actual building of the thing, there's the testing, there's the reviewing. All of this is part of your software factory. And so, who cares? Why is the software factory so important? It's because your output per unit of time goes parabolic. This is what really matters. I've said this before. I'm going to keep saying it. There's an engineer right now that's prompting back and forth in their terminal. Maybe they're running two, five, 10 agents. The number doesn't really matter because the other engineer, you and I, we are going to be building factories. And when you build the factory, you can reproduce that focused result over and over and over. You write one prompt and your factory of agents and code work together to produce a massive result to produce an entire feature to produce an outcome. This frees you from being stuck inside the terminal which ties directly into another key pillar AFK agents. We'll get to that in a moment. But if this idea

[00:09:01]

makes sense, drop a like and subscribe because this means that you understand the true leverage available for agentic engineers. You have to invest the time in to your software factory. And this is also known as the dark factory. In tactical agent coding, we call these ADWs, AI developer workflows. And the whole idea is to combine agents plus code to outperform either loan to get repeat results in your system, not anyone else's in your system. You teach your agents to build just like you. When you build your factories, you template your engineering. It allows you to produce that highquality car over and over and over, that high quality result over and over and over. Just to kind of put the stamp on this, it's your result. You're creating a stamp, a system of reproducible results that's on spec every time. Your test, your validation. When you build a factory, it always runs. Always getting that verification. You're releasing just like you would. Maybe you have a staging environment here that you can preview to validate. Maybe you have a whole team of agents that runs and fixes all regressions.

[00:10:02]

It's this system, right? It's that factory of results that you're creating that you can tap into when you build the software factory. So, this is an idea I'm spending a lot of time thinking about. You don't build the feature. This is a mindset shift. I'll be honest with you, this is hard to do. You have to shift yourself from thinking I'm the engineer that builds the feature. No, you're the engineer that builds a system of AI plus code that operates on your behalf. You're building the software factory. You are building the system that builds the system. This is the key thesis inside of tactical agentic coding and on the channel we talk about this all the time because it's so important and I want to be like really really blunt with you here. Uh the industry right all the top 500 companies everyone is building a software factory. Uh soon this will be a requirement. This is how you get massive leverage out of your tokens by the end of the year. All of your products that are in production you should have software factories. You should be able to write a prompt and then see a result near production. And if you're doing really really well and

[00:11:00]

you're really owning this, you might be getting close to ZTE, zero touch engineering, where you go from prompt directly to production. That's super super advanced. We're not going to focus on that here, but that's where this all goes. All right, ZTE, zero touch engineering. But none of that matters if you don't have the factory that can build the features for you on spec every single time. This is not a black or white thing. This is a great thing. It takes a lot of practice, a lot of agentic engineering. This is a new skill just like full stack, just like backend, just like front end, just like DevOps. This is a software engineering skill that takes practice. There's a practice in building agents that can operate for you on your behalf, but the end result is you get a software factory. Let's move on to the next big idea, extensible software. I would say if there are two ideas that I've personally missed, it's controlling your agent harness and it's extensible software. being fully honest, transparent here. These are the only two ideas I missed in tactical agent coding, which is why I've added an extended course into Agent Horizon. And this is why I'm talking about um the PI Asian

[00:12:01]

harness so much on the channel right now. But it's not just about the harness, right? This is about software in general. You want to be writing extensible software. It's very very clear why. This is probably not a surprise to you as a senior engineer. It's really about the number of changes that's happening in the industry. We have model changes. We have new prompts, new tools, new technology. We have change happening all the time. And the best way adapt to change is to build it into your software. You want to be building pluggable software, easy to extend, easy to change, easy to tweak. It needs to be adaptable because, as you know, models will change, tools will change. These things are are moving at light speed. The pace will only continue. Software is going parabolic right now. GitHub is crashing all the time. critical services changing all the time because we'll be operating at the agentic speed. And so if your software is complex, if your software is slow, if it's brittle, if you are vibe coding trash, you have not seen or read, if you're generating more slop, creating more tech debt in your technology, you

[00:13:01]

will suffer, right? Extensible software is something I'm thinking about a lot right now. And again, there's two kind of classes for this. There's engineering work and there's product work. There's enhancing your development. And a great example of this is your agent harness. And then there is production work. Whether you're deploying agents into production for agentic products or if you have traditional software where you know AI isn't involved, it doesn't really matter. You need adaptation. Agent harness is a great example of this, right? Constantly. There are different tools, there are new prompts, there's new agents you want to be testing, different system prompts. You want to be able to control the model that you're using all the time. This is why the PI agent harness is so important. It's so swappable. It's so dynamic. You can change this thing on the fly. When you're thinking about extending your lead as an agentic engineer, I highly, highly recommend you think about how you can make all of your software more extensible. Pluggability is the key. Extensibility is the key. Composability is the key. If your software has a million trillion rules

[00:14:00]

and operates in a very specific line of cascading if statements, the next year is going to be really, really hard for you because your agents will be really slow. they'll be making a lot of mistakes and you have to teach them in your software how to navigate all that. If you have extensible software, adaptable software, if you are adding and not modifying, you will have a massive advantage. This is one of my favorite software principles, open to extension, close to modification. Right. So, I'm thinking about that a lot as I use agents every single day as I'm building both a new agentic engineering workflows for myself to improve and increase my speed, but also on the product side, thinking about how to build great products that survive and thrive in a world where change is the default mode. Build extensible software. All right, makes sense. And if you're a senior engineer, you know this. These are ideas I'm re-emphasizing as I'm resetting my context for this next phase of work. Always on agents. When we talk about the ceiling of agentic engineering, this is one of the most important ideas. It's not enough to just have an agent that's always running.

[00:15:00]

Anyone can set up a crown job, spin up an agent, run a wild loop on an agent, and just have it always be burning tokens. The key here is useful tokens. In Silicon Valley, in a lot of these tech companies, there's a term called token maxing. You've probably heard of it. Token maxing sits at the lowest level of our economic funnel of tokconomics. Okay, so there's three levels here. First, you need to use more tokens. Then, you need to make your tokens useful. And then you capture the revenue generated by the value you created. Okay? So, these are the three levels. Now, if you're token maxing, you're very likely down here. You're just using more tokens. This is great. It's a great place to start. Terrible place to finish. Once you're spending tokens in your agentic systems, the next step is to make them valuable. And I think this is, you know, where a lot of companies, a lot of engineering teams, a lot of adopters of agents are really sitting right now. A lot of tokens getting generated, not a lot of value getting generated. And this is the trick of engineering. Only after you do that are you able to move to that highest level. Now, why am I saying this? Why is this important? It's because once you

[00:16:01]

generate valuable tokens and once you can capture that arbitrage, the next step, the only clear step is to turn them on all the time. This is the ceiling of agentic engineering. Agents that are on for you, operating, working while you sleep. But in order to get there, you must understand the token arbitrage. This is what everyone with their head on their shoulders is trying to do. If you're a senior engineer looking at the best way to spend your time, it's following this equation. We're all purchasing tokens right now. If you are at level two, you've made them useful, then you roll them into your products or your engineering experience. Once you've generated value for your users or for yourself, the next thing to do is to capture the value, right? You need to capture the actual revenue generated by your tokens. And so, it's these three levels that matter. First you use more tokens. Then you make your tokens valuable. And then from your tokens that are valuable, you need to turn that into real revenue. That's the arbitrage that's happening right now. This is what everyone is and should be focused on right now. You buy the tokens

[00:17:00]

at a certain price. You make them useful. You roll them into your products and your engineering experiences. And then you need to capture the actual revenue generated from them. This is the token arbitrage. This is what matters. This is tokconomics. And then the whole key is once you can successfully do this, you turn it on. You have always on agents, AFK agents. When you do this right, you then have a new KPI, right? Your rising API bill is a new productivity KPI, but only after you get out of level one and level two, because then this turns into a classic business problem. How many tokens can you spend? What are they worth to the business? And then you capture that difference. So, if you pay a dollar for a token and you can through your business generate a $110 worth of value for that token and then you capture that 10 cents, right, you have an infinite cash generating glitch, also just known as a business. And then all you need to do after that, just like when you have a great ad campaign that's running, you just scale it to the moon, right? You spend as many tokens as possible. This is literally what you see in the big AI labs. With more tokens

[00:18:01]

that they can sell, they make more money. But contrary to popular belief, I believe this goes all the way through the stack, all the way down to uh companies, all the way down to individual developers like you and I. If you can buy a token for a dollar, run it through your business process and sell it for $2, that's a 2x right there. And then all you need to do is smash tokens and scale it up. So it looks something like this. Your API cost should go up and the value you're generating should go up directly with it. Ideally greater than the cost. It doesn't need to be a linear scale. It most likely will be, but this is a simple idea. And once you do this, the whole idea is to scale it, right? Turn that system, turn that agent, turn that product on all the time. And so I'm thinking about this and the trick here is they have to be useful tokens. Token maxing once again, it's the floor. I can spend millions of tokens right now. I think you would be very very surprised to see my token usage is actually quite low. My token growth is a very very smooth curve because once I find that key value, that arbitrage, once I unlock value

[00:19:00]

generation and turn that into revenue capture for whatever business, products, clients I'm working with, that's when you scale it to the moon. But it's only at level three. If you're doing it at level one or level two, you're just token maxing. Once you do that, you turn that agent always on, you turn that product, that system always on, that agent harness, turn it on. But always think through that first. And this is the key difference between that high performing engineer using the exact same agent and the exact same number of tokens. If you're generating more value and you're capturing the value from the tokens you generate, you will be ahead of the pack. You will be capturing more revenue and therefore delivering more value. And only then do you turn it into an always on agent. There are a million agent crown jobs running. 90% of them are dead useless and just burning cash, burning tokens. Agentic access. So the headliner here is simple. You likely already understand this idea, but it's very important to emphasize because I know for a fact that you, the senior engineer, you probably haven't given your agent API access to all the things you really could to maximize your

[00:20:01]

agentic speed. API access is a requirement of agentic speed. Let's just quickly go through this. The ideas here are simple. You already understand this, but it's really important to re-emphasize. As I'm refocusing my personal context for this next phase of work, I'm thinking about always moving at the agentic speed. If there's something an agent can do, uh you have to really deeply ask yourself why it isn't it. And a lot of the times it's just because you haven't given your agent the API access it needs. But this is how you get the agentic speed. Okay? And this is the only way to operate now. CLI tools, rest, web hooks, RPC clients, you know the deal. Agents only command what they can programmatically reach. And in order for them to act and operate like you, you need to give them the tools that you have access to. There are limits here. You don't want to be giving production access so that they can nuke your production databases, your volumes, your resources. As talked about in a recent video, you want to lock down that bash tool so that your agents never do anything catastrophic. But the idea is very simple. You want to avoid the token tax. So what is the token tax? It's basically anything your agent does that

[00:21:01]

is unnecessary strictly because you haven't given it direct API access. You want your agents using tokens only when they need to to do the thing that is the most useful and valuable to you, your company, your product, your users. Don't pay a token tax. And this is that simple mindset shift that you already know. I know that you know this API access is a requirement of moving at the agentic speed. Agents, they're 10, hundreds, thousands of times faster at operating digital information than you or I. This is also why we don't work on the feature. We work on the agents that build the feature, right? We build the system that builds the system. It's the same thing. We want to be moving at the agentic speed, the speed of agents, but you can't do that if they don't have API access. So once again, I am refocusing my context around this. There are things you and I are doing right now. We don't have to be, but we are because we just haven't invested the time to give our agents the tools, the access, the resources that they need. So make sure you do that exactly. Okay. So these are the five pillars that are going to compound your advantage toward the one

[00:22:00]

opportunity that matters the most right now. Okay. It's agentic engineering. Karpathy said it. The entire industry is catching up with this. You're going to hear these kind of similar terms come around all the time, right? Dark factory, software factory, air developer workflows, always on agents, AFK agents, agentic access, extensibility, agent harnessing, right? Harness engineering. These are all ideas that are going to come up over and over and over in different forms and shapes. Uh, as I've been saying on the channel, success is often about doing a few very simple things over and over and over and over and over. And and you've seen this, you know this that the name of the game, the one opportunity, the thing you need to focus on, and I'm saying you, but really, as I mentioned, I created this presentation. A lot of the work I do is like a note to myself. It's a reminder to myself. You want to be agentic engineering. You want to be building the system that build the system. You want to be focusing on pillars that compound, actions that compound so that you can really tap into the ceiling of agentic engineering. Stack your advantage, compound the opportunity, raise the ceiling of your agentic engineering.

[00:23:01]

Vibe coding is the lowest hanging fruit. Do not sit in the terminal prompting out your features. Build the software factory. Own the agent harness. Use extensible products like the PI agent harness, but also make your products extensible by nature. Build it into the fabric of the work you're doing. Learn to arbitrage your tokens. Spending a bunch of tokens that do not generate value is meaningless. You need to spend more tokens. You need to figure out which ones are actually valuable. And then you need to capture the value usually via revenue from your tokens. Then once you do that, you turn that thing on so it runs 24/7. Always on agents, AFK agents, get that maximum value you can out of that system. And then, you know, more of a reminder than anything, if there's something you're doing that your agents can't do, why aren't you, right? Give your agents access. Make sure you're always focused on agentic access. Agent first systems, agent first products, agent first

[00:24:00]

workflows. Expose your CLIs and APIs everywhere. Code bases, products, devices, tools. Agents can only command what they can reach. If you're not doing this, but you're still using agents, you're paying a token tax. You're burning up tokens because you didn't put the upfront investment into the system that you need to. Again, this is more of a reminder to myself. A lot of the things I do on the channel, they're for me as much as they are for you. But this is what I'm focusing on every day as an engineer right now. The gap between, you know, the top 2% of engineers and everyone else is widening every single week. Why is that? It's because they are compounding their advantage with this one opportunity. It's very rare that you're presented with an opportunity to compound advantage. Don't miss this. Move slow now to move fast later. Invest in your agentic layer. Don't sit in the terminal vibe coding. Agentic engineer your work. build the system that builds the system. I have a bunch of links that I'll share in the description for you. Previous videos where we talk about the pietoie customized agent harness. I'll of course share tactical agentic coding

[00:25:02]

for anyone that's interested in understanding what is possible right now with agentic engineering and what will be possible once you put the reps in. A big shout out to uh Mario and everyone working on the PI Asian harness. This tool has been incredible to work with. As I mentioned, I'm building a new Asian harness every single day now, which is really absurd. You can imagine I have a software factory that lets me do this. So, bunch of links in the description for you. Check all them out. Bunch of free stuff, some paid stuff if you're interested in that extra push. These are the five big ideas I'm focusing on. I'm reentering myself on. I'm emphasizing in all of my work, and so I recommend you do the same. Comment down below if you think I missed anything. You'll notice here I didn't mention models a single time. That's because models matter less and less. They matter for bleeding edge work, but for a lot of the work, 80 90% of the work we're doing on a daily basis, what matters is the systems you place around your agents, we are talking about agentic engineering, which to be clear, it's the process of engineering

[00:26:00]

with intelligence that can operate on your behalf. So, five big ideas for you. I've got more resources linked for you in the description. Shout out Pi. Shout out Mario. Uh, shout out Andrew Carpathy. Shout out Claw Code. And um, thank you for watching to the end here. You know where to find me every single week. Stay focused and keep building.