Big Idea

The argument in one line.

The AI coding model you obsess over is only 10% of what determines your output — the harness of context, guardrails, and workflows around it is the 90% that makes or breaks production-grade agentic engineering.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You use Claude Code, Cursor, or Copilot regularly and want a framework for making your AI coding sessions more reliable and less token-wasteful.
You are evaluating whether to invest time building memory files, rules, and agent workflows — and need a business case before committing.
You have heard the phrase 'vibe coding' and want to understand where it fits on a principled spectrum rather than treating it as a binary on/off.
You manage a team adopting AI coding and need a mental model for how to think about spec quality, harness engineering, and the role of the human reviewer.

SKIP IF…

You are looking for hands-on tool tutorials — this is a conceptual framework video, not a step-by-step setup guide.
You already think deeply about harness engineering and context management; this is introductory-to-intermediate territory.

TL;DR

The full version, fast.

Google's 51-page whitepaper argues that AI coding is a spectrum from casual vibe coding to full agentic engineering, and the differentiator is not which model you pick — it's the harness you build around it. The harness (instructions, tools, guardrails, memory, MCP servers, agent skills) accounts for roughly 90% of your results; the model is the remaining 10%. The practical implication: invest upfront in specs, rules, and automated evals (high CapEx) rather than burning tokens iterating on sloppy prompts indefinitely (high OpEx). Context engineering — deciding what goes in static vs. dynamic context — is the core skill to develop.

Free for members

Chat with this breakdown — free.

Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.

Create a free account →

Chapters

Where the time goes.

00:00 – 01:16

01 · Google's AI coding masterclass

Intro and credibility framing — multiple people told Cole this paper looks like he wrote it. 51 pages distilled in 22 minutes.

01:16 – 02:17

02 · What even is an SDLC?

Software Development Life Cycle defined: idea through requirements, design, implementation, testing, deploy, maintenance.

02:17 – 03:44

03 · The new bottleneck: requirements and validation

AI compressed implementation from weeks to hours. Requirements gathering and end-stage validation remain human-paced — these are the new bottlenecks.

03:44 – 06:43

04 · AI coding is a spectrum, not a switch

Three points on the dial: vibe coding, structured AI-assisted, agentic engineering. The differentiator is how the output gets verified, not whether you use AI.

06:43 – 09:27

05 · The harness: why the model is only 10%

Agent = Model + Harness. Harness = instructions, tools, context, guardrails, orchestration, observability. Both Anthropic and Google converge on this framing.

09:27 – 11:04

06 · Sponsor: BetterDB

Open-source self-tuning Valkey/Redis caching and observability for AI agents. Semantic cache demo shown live.

11:04 – 13:37

07 · Harness engineering and the factory model

Developer role shifts: design the system, delegate all coding to the agent. Plan agent and coding agent should be separate sessions to avoid context rot.

13:37 – 15:02

08 · The system evolution mindset

Don't just fix bugs — have the agent retrospect on failures and improve its own rules. Each pass makes the harness more reliable.

15:02 – 16:42

09 · Why the harness is worth the investment

Terminal Bench 2.0 data: harness alone moved a model from outside top 30 to top 5. LangChain +13.7 pts equals the Sonnet-to-Opus gap.

16:42 – 17:55

10 · Static vs. dynamic context

Static = always loaded, reliable, expensive. Dynamic = on demand, efficient, risky. Context engineering is the core skill of agentic development.

17:55 – 18:53

11 · Agent skills: one agent, many specializations

Skills are structured portable packages of procedural knowledge. One generalist agent flexes into specialist roles via progressive disclosure — no need for complex multi-agent systems.

18:53 – 19:53

12 · Conductor vs. orchestrator

Conductor = keystroke-level in-IDE steering. Orchestrator = async goal-level, spanning codebases, agents in parallel. Cole's view: build the harness until you live at orchestrator full-time.

19:53 – 22:22

13 · Token economics: CapEx vs. OpEx

Vibe coding is low CapEx, high OpEx (constant token burn). Agentic engineering is high CapEx, low OpEx. Crossover arrives quickly — 3-10x cheaper per feature shipped.

22:22 – 21:55

14 · Outro

Recap and subscribe CTA.

Atomic Insights

Lines worth screenshotting.

The AI model you use for coding is only 10% of what determines the output quality — the harness you build around it is the other 90%.
Specification quality is the new bottleneck: AI compressed implementation from weeks to hours, but requirements gathering and validation are still human-paced.
AI coding is a spectrum, not a switch — vibe coding, structured AI-assisted, and agentic engineering are three points on a dial, not three separate tools.
The differentiator between approaches is not IF you use AI, but HOW the output gets verified.
Most agent failures are configuration failures, not model failures — benchmark data shows harness changes alone drive the biggest performance jumps.
LangChain improved Terminal Bench 2.0 scores by 13.7 points with harness alone — that is the gap between Sonnet and Opus.
You can make Sonnet perform at Opus-level if you have the right system and process wrapped around it.
Static context is reliable but expensive; dynamic context is efficient but risky — the agent might not load what it needs when it should.
Agent skills are the most powerful pattern for managing dynamic context: structured, portable packages of procedural knowledge loaded only when the task calls for it.
You really only need one generalist agent — skills turn it into a specialist on demand through progressive disclosure.
Vibe coding has low CapEx but very high OpEx because you burn through tokens iterating on code with no grounding system.
Agentic engineering has high CapEx (building the harness) but low OpEx — and the crossover point arrives quickly.
The planning agent and the coding agent should always be separate sessions to avoid context rot and accumulated bias.
The system evolution mindset: whenever your agent has to iterate more than expected, have it retrospect and improve the rules rather than just fixing the bug.
The next billion-dollar platforms will likely be tools that speed up requirements gathering and validation — the parts AI has not yet compressed.

Takeaway

The model is 10%. Build the other 90%.

WHAT TO LEARN

The AI coding tools most people obsess over are a small fraction of what actually determines results — the system, rules, and workflows wrapped around the model is where the real leverage lives.

Specification quality is now the primary bottleneck in software development — AI compressed implementation from weeks to hours, but requirements gathering and validation still require human judgment.
The differentiator between vibe coding and agentic engineering is not which model you use; it is how rigorously the output gets verified at each stage.
A harness of instructions, memory files, guardrails, and agent skills can lift a cheaper model to the performance level of a more expensive one — benchmark data shows a 13.7-point improvement from harness changes alone.
Separating the planning agent from the coding agent is a structural habit, not a preference: long planning sessions build up context rot and bias that contaminates the subsequent build.
Static context (always-loaded rules and guardrails) is reliable but expensive; dynamic context (skills and RAG loaded on demand) is scalable but requires the agent to know when to reach for it — learning to balance these is the core skill of context engineering.
Agent skills — structured portable packages of procedural knowledge — let a single generalist agent specialize on demand, eliminating the need for sprawling multi-agent systems with hard-coded specialists.
The system evolution mindset treats agent failures as harness improvement opportunities rather than one-off bugs: each iteration makes the rules and workflows more reliable for every future task.
Vibe coding appears cheaper at first (no upfront harness investment) but generates very high ongoing token costs from constant iteration on ungrounded code; agentic engineering requires upfront investment but reaches a crossover point quickly and then runs 3-10x cheaper per feature shipped.

Glossary

Terms worth knowing.

SDLC: Software Development Life Cycle — the full process from idea to production, including requirements gathering, design, implementation, testing, review, deployment, and maintenance.
Harness: The set of context, rules, guardrails, tools, and workflows that wrap an AI coding model. It is the layer the developer controls and accounts for roughly 90% of agent output quality.
Agentic engineering: The most structured point on the AI coding spectrum: the model operates within a purpose-built harness of specs, automated evals, CI gates, and quality workflows that let it iterate and self-correct before human review.
Vibe coding: The least structured end of the AI coding spectrum: casual natural language prompts with minimal planning, where success is validated by 'does it seem to work?' rather than automated tests.
Agent skills: Structured, portable packages of procedural knowledge — workflows, conventions, or domain rules — that the agent loads on demand rather than having them embedded permanently in the system prompt.
Static context: Information loaded into every agent session automatically (system instructions, core guardrails, persona). Reliable but expensive because it always consumes context window space.
Dynamic context: Information the agent retrieves on demand (via RAG, skill files, tool results). Efficient and scalable, but carries the risk that the agent may not fetch it when it should.
Context rot: The degradation in agent reasoning that occurs when the context window fills with accumulated tokens from a long session, causing the model to lose track of earlier instructions or build up bias.
Factory model: Google's framing for agentic engineering: the developer's role shifts from writing code to designing the system (harness + specs + quality gates) that produces code.
Terminal Bench 2.0: A major benchmark used to compare AI coding agents. Referenced here to illustrate that harness changes alone can move a model from outside the top 30 to the top 5.
CapEx / OpEx (AI coding context): Capital expenditure = the upfront investment to build the harness; operational expenditure = the ongoing token and rework cost to produce each feature. Vibe coding has low CapEx but high OpEx; agentic engineering reverses that ratio.

Resources

Things they pointed at.

00:06linkGoogle Whitepaper: The New SDLC With Vibe Coding ↗

07:55linkAnthropic Claude Code best practices article

09:27toolBetterDB ↗

14:00toolTerminal Bench 2.0

14:48linkLangChain harness benchmark study (+13.7 pts)

11:04productDynamous Agentic Coding Course ↗

Quotables

Lines you could clip.

07:13

“The large language model that you use for your AI coding assistant is only 10% of the system.”

Counterintuitive claim with a number attached. No setup needed.→ TikTok hook↗ Tweet quote

14:55

“You can make Sonnet work as well as Opus if you have the right system, the right process that you're having it go through as the harness.”

Contrarian, specific, and actionable — challenges the model-obsession default.→ IG reel cold open↗ Tweet quote

02:19

“Specification quality is the new bottleneck.”

Short, punchy, reframes where the real work is now.→ Newsletter pull-quote↗ Tweet quote

20:41

“Vibe coding is gonna be cheaper at first — lower capital expenditure. But the problem is it's very high operational expenditure because you start burning through millions and millions of tokens.”

Business-language framing of a technical trade-off. Easy for non-engineers to grasp.→ TikTok hook↗ Tweet quote

The Script

Word for word.

Read-along

Don't just watch it. Burn it in.

See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.

metaphor

00:00So a new master class on AI coding was just dropped by Google and it is really good. It's a high level overview of pretty much everything that I teach on my channel. In fact, a couple of people actually sent this to me last week and they said, hey, Cole.

00:14This literally looks like it could have been written by you. It's the cleanest packaging I've seen for everything that the industry is converging on right now as far as best practices and terminology for AI coding. It's very well written, definitely worth a read.

00:29So I'll link to it in the description, but it's also 51 pages long. So it takes a while to get through this, which is why I wanted to make this video just to disseminate everything nice and quickly for you. And even if you're already pretty comfortable with agentic engineering and AI coding, it's worth going through this.

00:45Right? The old adage is you don't truly understand something until you can teach it well. So it's important to take the instincts you build over time and turn that into a clear visualization, mental model, and precise terminology.

00:58And so that's what we really get with this on everything the industry is converging on. And so I've reordered things a little bit and what I'll show you here, I think there's a better ordering than what they present. But I wanna go through this all with you along with a diagram that I have prepared and just give the good parts to you really fast.

01:14So let's get into the meat of it here. So the first big question we have to answer here is what the heck even is an SDLC? If you don't come from a technical background, you're probably not even familiar.

01:24And there's the new phrase AI driven SDLC that's being thrown around all of the time now. So it's short for software development life cycle.

01:32And quite simply, it's the process to go from idea all the way to production. So requirement gathering at the start, all the way to review deployment and maintenance. And so it's a lot more than just writing the code that sits in the middle.

01:45And with a traditional SDLC, you spend a good few days gathering requirements with your stakeholder meetings and the product manager creating the PRD, like all that documentation upfront. And then you have a couple of days of designing.

01:57And then the implementation is usually what would take most of the time. The engineer spending weeks writing the actual code before you then go into the final steps of testing, reviewing, deploying, and maintenance. And usually that would take a week.

02:11Obviously, it depends a lot per company. Just a general idea through, uh, generalization here. And so now with the AI driven SDLC, the important thing here is that everything we do upfront and at the very end, it's not actually that much faster now.

02:26The specification quality is the new bottleneck, and that is so true because there's so much that still has to be human driven with the validation at the end and the requirement gathering upfront. And so really it's only what's in the middle here. The implementation has gone from one to three weeks to minutes or hours with AI coding assistance.

02:48The same thing is dozens of times faster, especially because agents can iterate with their own system of tests and evals that we'll cover in a little bit. And so we have the bottleneck at the start and at the end. And I firmly believe that a lot of the next $1,000,000,000 plus companies are gonna be platforms that help speed up the requirements gathering and the validation.

03:09Because we've solved way more for what we have in the middle now. And so that's why you hear so many statistics around like AI coding assistance 10 x ing the engineers output, but not actually 10 x ing the output of the business is because we're bottlenecked by other parts of software engineering.

03:25Software engineering is a lot more than just writing code. But the thing is, as much as you can, you want to remove implementation as the bottleneck because that is still going to save you a considerable amount of time. And so doing that and just generally making everything else in the AI driven SDLC as fast as possible is what this article focuses on.

03:44And so that brings us to the first thing that I wanna cover in the diagram. So I took all the big long ideas from the article, made it nice and concise for you here. And so the first thing that they talk about is that AI coding is a spectrum, not a switch.

03:58And I really appreciate that because most people think of it as something that's binary. Either you're vibe coding or you're doing agentic engineering. But it is a spectrum depending on the level of your system.

04:11And so we'll talk about the system and the harness in a bit. But vibe coding is where you send in a prompt without much planning and then your validation is, hey, does it seem like it work? Right?

04:21Like, you'll test the application a little bit, uh, and then you'll just move on to the next iteration. With structured AI assisted, we have more detailed prompts, we're doing more spot checking, and then we get all the way to agentic engineering where we have a entire engineered set of resources and workflows for our AI coding assistant with specs and automated evals and CI gates so the agent has a way to really iterate and figure out things that go wrong before you have to correct it.

04:49This is where the real power comes in. And so it's not like we always need agentic engineering. Sometimes vibe coding is actually enough for proof of concepts or you just want to create an MVP.

05:00I used to just always dismiss vibe coding, but I think there is genuinely a place for it. And so the spectrum Google is saying is not just like you're evolving yourself. It's you pick the right one for the job.

05:12It's just agentic engineering is usually where you want to be because this is where you're really creating reliable code. And in the article, Google also has this table that I really appreciate. It makes things nice and concrete.

05:23So for each level, what does it look like for these different dimensions? And so for intense specification, for example, which is just how do you communicate upfront what you want.

05:33For vibe coding, it's just casual natural language prompts. So you're just describing at a very high level what you're looking for. With structured AI assisted coding, the middle of the spectrum, you're getting more detail but you still don't really have a workflow for creating formal specs, architecture docs.

05:48Like when you get to agentic engineering, this is where you really have a repeatable process and you have specifications that are actually engineered just like the code. And then for verification, like we covered this a little bit already, but for vibe coding, it's more does it just seem to work? You're not doing much of a deep dive at all.

06:04With structured AI assisted coding, you're getting a little bit into it with more manual testing and spot checking of the code maybe. And then for agentic engineering, this is where you have the whole process for the agent to iterate itself with tests and CICD gates. Also LLM judges, you have a separate code review process for yourself and another agent.

06:22And I don't need to cover everything here, but getting down to the risk profile, with vibe coding, it's high. Right?

06:29Like acceptable for disposable code like I was saying earlier, but then if you really want the most reliable code possible, that's where you want systematic verification at every stage that comes with agentic engineering.

06:43Okay. So if agentic engineering is the way to go most of the time, how do we actually do it? Like, what separates agentic engineering from vibe coding?

06:52And really everything can be wrapped up in the harness. So the harness is the set of context, rules, and workflows that you bring into the AI coding assistant.

07:03It's the layer that you control. And the big thing that Google is claiming here is that the large language model that you use for your AI coding assistant is only 10% of the system or it only matters 10%.

07:18Everything else like your instructions and tools and context and guardrails and orchestration and observability, like there's so much here that makes up the other 90%. And that's actually a really good thing because the model is what we don't control. The harness is what we get to create for our specific code bases, architectures, and tech stacks.

07:38And it really is true that the industry is converging on a lot of these things. Like, we have this article from Anthropic that I covered a couple of weeks ago on my channel. Just best practices for using Claude code in general.

07:49And one of the headlines that they have here is that the harness matters as much as the model. And so now Google and myself as well, we're taking this even further to say not only does it matter as much, but it actually matters more than the model. Like the model only being 10%.

08:05Clearly Google is like, okay, you need to put your focus on the rest of the harness here. And they also have a very similar definition of what goes into the harness. So Claude code right here, they say it's your global rules, it's your hooks like the deterministic actions you want in your life cycle, your skills, so the workflows that you have packaged up, uh, your ways that you search your code base, the MCP servers, and your sub agents.

08:29Like, these are all of the primitives as I call them for working with literally any AI coding assistant. And if we go now into Google's article here, they say the agent is the model plus the harness and they have this diagram that lays out exactly everything that goes into the harness and you can see this is where I got the numbers by the way.

08:47So the model being 10%. So you have the large language model in the middle. Still matters to an extent because it is the brain, it is the reasoning in your system, but everything else around it is a huge deal.

08:58So you have your instructions, the MCP servers, guardrails, and hooks. I mean, everything is the exact same as what Anthropic presented in their article.

09:06And then the layer above is where you have all of the testing infrastructure. So the evals and testing for the agent to iterate itself. And then the top layer is more for you and for production.

09:17So the observability and tracing, scaling, right, like that's pretty important when you wanna take anything an AI coding assistant produces and actually take it all the way production.

09:27The sponsor of today's video is BetterDB, a self tuning val key slash redis caching and observability platform for AI agents and it is open source. So we're talking all about the AI SDLC in this video, but not covering that much tools we can use to help us with reliability and monitoring in production, that end stage of the SDLC.

09:49And BetterDB is a fantastic example of an AI native tool that can help us with this. So monitoring our database in production, using our AI coding assistant with it to suggest changes and improvements based on live production data and a semantic cache to help us scale our database.

10:06Let me show you how these things work really quick. My favorite part of BetterDB is the semantic cache. Take a look at this.

10:12You'll see how it works very quickly. If I ask what's the capital of France, it's not in my BetterDB cache yet, so it's a miss and it calls a model to get the answer. But the next time I ask something that is similar, we get a cache hit.

10:23It doesn't even have to be the exact same wording because it's semantic similarity search like traditional regs. We get a much faster answer. And we have an MCP server, we can connect to our AI coding assistance directly to our better DB cache so we can ask how it's doing.

10:39We can have it suggest improvements and even make those directly. So it's very easy to improve our system over time with the help of AI. And then also we have a dashboard to monitor everything so we can see how our agent and our cache is performing in production with real user data.

10:53And the best part is BetterDB is open source and free to get started. So I'll have a link in the description. I'd highly recommend them as a tool to help you scale, manage your cost agents you're deploying to production.

11:04And so now Google is saying with harness engineering, we have the idea of the factory. So instead of the engineer writing the code or the product manager writing the PRD by hand, instead we are responsible for designing the system, creating the harness, and then the agent is the one that is actually producing our code and documentation.

11:23And so this is more of an investment upfront than vibe coding because we have to create the specs and guardrails, but then we use that to then go into this repeatable system of we plan with the agent, we have it build, and then we have our quality gates at the end for testing and eval ing with an iterative loop here for the agent to improve its output autonomously and then get to the point where we have something for us to review and ship.

11:44And so this entire thing, we wanna delegate all of the coding to the AI coding assistant. Even with agentic engineering, you are delegating all of the coding. So this is not a spectrum of how much do we write by hand versus trust the agent.

11:57It is just a spectrum of how evolved of a system do we actually have here. So Google does get a little bit repetitive here because when they talk about the factory model for the first time and what goes into it, it's really the same thing as what goes into building a harness or the AI layer they already talked about. So it's your your context and rules, your test and quality gates, your workflows, your guardrails, and your hooks.

12:18Right? But they have a really good visualization for where the developer actually stands in the process now. So we define our specs, context, and requirements upfront, and you use those specs for your planning agent.

12:29So every single time you build anything with an AI coding assistant when you're doing agentic engineering is you're going to have one agent that does the plan for the bug fix, for the new feature, whatever it is. And then the guardrails that you design in like the sandbox environment, that is what's gonna be used by the actual coding agent.

12:46But it's important here that you do split this into two separate sessions because your planning agent is going to build up a lot of context, you wanna avoid context, Rod, and it's gonna build up a lot of bias. And so you take the plan as an artifact, you send that into the coding agent, and then you do your test and verification and iterate there.

13:04And this is also where we can come in the loop to review and approve things ourselves because you definitely fall more into vibe coding if you're not reviewing the output yourself even if you do have quite an autonomous system. Right?

13:16Like even if it's just that pull request at the end. For agentic engineering, generally, you want a human to be reviewing that before you mark it as passed and you go on to the rest of the process for deployment to production.

13:29And throughout this entire workflow, that's where we have our guardrails, like token limits and security policies, everything that you are engineering up front. And the really cool thing about this whole system is that we can make it better over time.

13:43Just like we evolve our code base over time, we can evolve our system. So I I call this the system evolution mindset. Whenever you encounter an issue with your AI coding assistant, like something comes up here where it has to iterate more than you would want or you have to step in before you ship, instead of just fixing the bug and moving on, you actually talk to your coding agent.

14:01Like you have it do some retrospection and say, hey, where could we make our workflows or our rules, like any part of our AI layer better so that issue is less likely to come up again. And so that way every single time you go through this process over and over and over again, you're making it more and more reliable. And the harness is worth investing your time into.

14:22Like it it really is the 90%. I mean, there's a lot of studies that are done like terminal bench two point o. It's one of the biggest benchmarks we have out there.

14:30Like every single time a new model comes out, this is one of the percentages that you see. There's a lot of studies done where like they were able to take a model from outside the top 30 into the top five just by creating an AI layer of rules and workflows for it to run through the things you usually test for the benchmark.

14:47Lane chain was able to increase it 13.7 points. Like that's the difference between Sonnet and Opus.

14:53Like you can make Sonnet work as well as Opus if you have the right system, the right process that you're having it go through as the harness. So if the harness is the most important part of agentic engineering, then it's clear that the most important skill within that is how do we engineer each of the individual components of the harness, like our rules, workflows, and a guardrails.

15:15And so we've covered the different components already, but a key delineation that Google makes here that I really like is the static context versus dynamic context. And this is really important because it's all about context management. Context is your most precious resource when working with AI coding assistance, both for the sake of cost and avoiding context rot.

15:36We don't wanna fill the window of our LLM, our coding agent too much because LLMs get overwhelmed with information just like people do. And so nice visualization here. They talk about what goes into static versus dynamic.

15:49So static context is things like your rules and the core guardrails, the system prompt. It's loaded into the coding agent session guaranteed every single time.

15:58That makes it reliable because the agent doesn't have to seek out this information, but it's expensive because you're filling the context window up front. And so it's important to have at least some rules and guardrails up front, but you wanna make them very lean.

16:11And then everything else goes in dynamic context. So it's efficient and scalable because it's information that the agent has to actually seek out. Like, you might have an an agent skill for planning, like it loads that skill when you want it to do the planning workflow, or you have conventions for a part of the code base you want it to load when it operates on that part of the code base.

16:29And so it's very scalable, so you're not shoving it into the context upfront, but the risk there is the agent might not grab for that context when it should. Like, it might not load the skill or perform the rag search when you would hope it to or when it would be optimal to do so. But large language models are getting better and better at relying on dynamic context and loading it when it should.

16:51And so like agent skills are becoming very, very important right now. Right?

16:55So they say rather than embedding every piece of specialized knowledge into the agent system prompt, skills allow the agent to remain a lightweight generalist that flexes into specialist roles on demand through progressive disclosure. And this is so important because the underlying lesson here is that we really only need one agent for everything.

17:15And then we can make it specialized with our skills, I e our workflows. And so something that people used to do way too much before is they would have these really complicated multi agent systems with all these specialists or they use a ton of these specialized sub agents they would create. And really the industry is moving away from that because we can't just have one generalist agent that we make specific with the skills that we have at load.

17:39Like we can have it become a code reviewer or become a planner. That session can turn into the specialization that you need thanks to dynamic context. So keep it simple.

17:48You really only need one agent to drive most of your agentic engineering. Okay. So the article has been very value packed already.

17:55There's just two more things that I wanna cover with you here. Wanna talk about your role as the conductor and orchestrator and then also the token economics.

18:04And so an interesting thing that Google presents here is the idea of you as the engineer are going to move between two modes as you're using your AI coding assistant. And so the conductor is more how we used AI coding assistance when generative AI was first a thing.

18:20Like we had our tab complete, we're still steering every move, working in individual files, that's the conductor. The orchestrator is a lot of what people have been focusing on more recently where we have a coding agent handling much larger tasks spanning entire code bases, maybe even multiple code bases.

18:37We're reviewing the outcomes instead of changes to individual files. We have agents running in parallel. We're really scaling our output with AI coding assistance here.

18:46And almost everybody is focusing entirely on this. And this this is like the one part of the article. I don't know if I agree with Google because they're saying that you actually wanna move between them both.

18:56Like, there's still a time and place to be micromanaging the AI coding assistant at a single file level. Honestly, I don't know if I agree with this.

19:05I think when you build the harness to be reliable enough and you're confident in your rules and workflows, you can always live at this level. But they do make some interesting arguments where it's like any kind of like deeper debugging you have to do or just initial exploration, like you are going to get very granular with the coding agent because that's the times where you might need to really be in the loop and guide it.

19:26So I think there's a time and place for it, but I feel like when you have the right system and it's working well for you, you don't really like, you kind of graduate from being the conductor. I don't think you're always moving between the two. But it is an interesting idea, especially as an organization when you have a lot of traditional engineers and you're first getting into agentic engineering.

19:45I think it is good to have this mental model just until you have the system developed where you'd graduate to only ever staying here. Cool. And then the very last thing that I wanna cover here is the token economics.

19:56I really love how they frame things here. So like we said, vibe coding, you don't always want to avoid it, but there is a big cost that comes if you lean on it too much. Because at first, when you're first adopting AI coding assistance for yourself or a company, vibe coding is gonna be cheaper.

20:12It's lower capital expenditure because you don't have to dedicate yourself or a team to design the initial harness. But the problem is it's very high operational expenditure because you start burning through millions and millions of tokens iterating on swap code because you don't have a system for your AI coding assistant to follow your workflow and your conventions.

20:32And so agentic engineering, it has that high capital expenditure because you have to dedicate your time upfront or you have to like in a larger organization, usually you create a smaller forward deployed engineer team to build up that harness to then scale to the entire organization. So you're dedicating manpower to build something initially, but then it scales extremely well because the output of your AI coding assistance are better and better and better over time and you have that grounding in a system that you just build once upfront and evolve over time.

21:01So high capital expenditure, but then low operational expenditure. And, you know, you have that crossover that you reach extremely quickly.

21:09Like, you want to just take the dive and build that system upfront because, yeah, you're gonna get to the point where agentic engineering is three to 10 times more reliable and cheaper than vibe coding because you're not burning through millions of tokens. So there you go.

21:23That is everything you need to know at a high level for the new AI driven software development life cycle. It is worth building that harness and investing in it. It is an engineered resource that lives in version control just like the code itself.

21:37So I hope that you found this useful. Let me know in the comments what kinds of content you want me to create to expand on any of these ideas here because this is my bread and butter. If you appreciated this video, you're looking forward to more things on agentic engineering, I would really appreciate a like and a subscribe.

21:52And with that, I will see you in the next video.

The Hook

The bait, then the rug-pull.

Google's 51-page whitepaper on AI-driven software development landed quietly — but Cole Medin noticed it before the algorithm did, and for good reason: the paper packages everything the industry has been converging on into one clean framework, with a headline that cuts through the hype. The model is 10%. The harness is 90%.

Frameworks

Named ideas worth stealing.

03:44model

The AI Coding Spectrum

Vibe Coding
Structured AI-Assisted Coding
Agentic Engineering

Three points on a spectrum, not a binary switch. Vibe coding = casual prompts, does-it-seem-to-work validation. Structured = detailed prompts, spot checking. Agentic = full harness, automated evals, CI gates.

Steal forExplaining to a client or team why 'just using AI' is not a strategy

06:43concept

Agent = Model + Harness (10/90 Split)

The model is 10% of the system. The harness — instructions, tools, context, guardrails, orchestration, observability — is the other 90%.

Steal forAny pitch on why investing in harness engineering beats chasing the latest model

11:04model

The Factory Model

Developer shifts from writer to system designer. You build the factory (harness + specs + quality gates). The agent runs the factory line and produces the code.

Steal forReframing what a developer's job looks like in an AI-native team

16:42concept

Static vs. Dynamic Context

Static context is always loaded (reliable, expensive). Dynamic context is loaded on demand (efficient, risky). The skill is knowing what belongs where.

Steal forDesigning any agent harness — memory files vs. RAG vs. skill triggers

18:53model

Conductor vs. Orchestrator Role Shift

Conductor: real-time in-IDE keystroke-level steering
Orchestrator: async goal-level multi-agent parallelism

As your harness matures, you graduate from steering every keystroke to reviewing outcomes at the PR level.

Steal forDescribing the developer career trajectory in an agentic engineering world

19:53model

CapEx vs. OpEx Token Economics

Vibe coding = low upfront cost, high ongoing token burn. Agentic engineering = high upfront investment in the harness, 3-10x lower ongoing cost per feature shipped. Crossover arrives quickly.

Steal forMaking the business case for harness investment to a manager or client

CTA Breakdown